UNIT 1: ABOUT SOFTWARE DEVELOPMENT
Detailed Summary
1. SOFTWARE & SOFTWARE DEVELOPMENT
1.1.1 Software (Definition and Characteristics)
Definition: Software is a collection of computer programs, procedures, rules, and associated documents
concerned with data processing system operation.
Key Point: Anything that can be stored electronically is called software.
Two Categories of Software:
• System Software: Responsible for controlling and integrating hardware components. Allows software and users
to work with them. Controls peripherals like monitors, printers, and storage devices. Example: Operating systems.
• Application Software: Used to accomplish specific tasks. Designed for end users. Examples: Microsoft Word,
Excel, Railway reservation systems.
Software Characteristics (Qualities of Good Software):
• Understandability: Software should be easy to understand, even for novice users. Should be efficient to use.
• Cost: Software should be cost-effective as per its usage.
• Maintainability: Software should be easily maintainable and modifiable in future.
• Modularity: Software should have modular approach for easy handling and testing.
• Functionality: Software should be functionally capable to meet user's requirements.
• Reliability: It should provide failure-free service.
• Portability: Software should adapt to different environments.
• Correctness: Software should be correct as per its requirements.
• Documentation: Software should be properly documented for future reference.
• Reusability: Code or logic should be reusable in future projects.
• Interoperability: Software should communicate with various devices using standard protocols.
• Verifiability: Software should be verifiable with its properties and functionalities.
Special Characteristics of Software:
• Software doesn't wear out: Unlike hardware which shows 'bath-tub curve' (high early failures, then steady state,
then wear-out), software follows an 'idealized curve' not affected by environmental effects.
• Software doesn't become worn: In early stages, software may have high failure due to errors, but becomes
reliable as time passes. Once made, it has longer life span than hardware.
• Software is engineered, not manufactured: Unlike hardware assembly, software is developed/engineered. No
assembly needed. Costs are in development, not material.
• Reusability of components: Software codes, modules, or logical components can be reused in other projects.
GUI software is often built using reusable components.
• Software is flexible for custom built: Any change needed in software can be done easily. Products can be built
on custom requirements and modified later as per user demands.
1.1.2 Characteristics of Web-Based Applications
Basic Concept:
• A Web application (Web app) is an application program stored on a remote server and delivered over the Internet.
• Users access web applications using a web-browser.
• Web applications use server-side scripts (PHP, ASP) and client-side scripts (JavaScript, HTML) for data storage,
retrieval, and presentation.
How Web Application Works:
1. User sends request via web browser → 2. Web server receives the page request → 3. Web server instructs
application server to process the page → 4. Application server processes and generates output → 5. Web server
sends output to browser → User sees result.
Characteristics of Web-Based Applications:
• Availability: Expected to be available 24/7 from anywhere in the world.
• Client driven: Primary function is to use hypermedia to present text, graphics, audio, and video content to end
users.
• Performance: Should present contents with minimum delay.
• Responsive: Should respond with any browser or device in proper way.
• Informational: Provides read-only content with simple navigation and links.
• Download: User can download information from the server.
• Customizable: User customizes content to specific needs.
• User input: Forms-based input is the primary mechanism.
• Database access: User queries large databases and extracts information.
• Data warehousing: User queries collection of large databases.
• Transaction oriented: User makes requests (e.g., orders) fulfilled by the web app.
• Security: Should be secure from hackers and unauthorized users.
• Usability: Should be easy to use with friendly and quick navigation.
1.1.3 Software Engineering – A Layered Approach
Definition of Software Engineering:
Software Crisis: The difficulty of writing useful and efficient computer programs in the required time.
Software Engineering (SE): An engineering discipline that covers all aspects of software from specification to
maintenance. It delivers high quality software at agreed cost and in planned schedule.
IEEE Definition: Software Engineering is the application of a systematic, disciplined and quantifiable approach to
the development, operation and maintenance of software.
Three Main Aspects of Software Engineering:
1. Provide quality product
2. Expected cost
3. Complete work on agreed schedule
Need of Software Engineering:
• To help developers obtain high quality software product.
• To develop product in appropriate manner using life cycle models.
• To acquire skills to develop large programs.
• To acquire skills to be a better programmer.
• To provide software product in timely manner.
• To provide quality software product.
• To provide software product at agreed cost.
• To develop ability to solve complex programming problems.
• To learn techniques of specification, design, user interface development, testing, project management, etc.
Software Engineering – Layered Approach:
Software engineering is viewed as a layered technology containing four main layers:
1. Quality Focus Layer: Focuses on quality product. Checks whether output meets requirement specifications.
Every organization should maintain Total Quality Management (TQM).
2. Process Layer: A set of activities that produce desired result. Main objective is to develop software in time.
Heart of software engineering. Holds all technology layers together like GLUE. Works as foundation layer. Defines
framework activities.
3. Method Layer: Provides technical knowledge for developing software. Describes 'how-to' build software
product. Creates SE environment using CASE tools (combines software, hardware, and SE database). Includes
requirements analysis, design, program construction, testing, and support.
4. Tools Layer: Provides support to below layers using automated or semi-automated tools. Ensures process is
executed properly.
1.1.4 Software Myths
Software myths are propagated misinformation that can cause serious problems in development.
Myth: Software is easy to change
Reality: Source code is easy to change, but making changes without errors is difficult and tedious. Proper care and
approach are needed.
Myth: Outsourcing of s/w to third party relaxes customers
Reality: True only if organization understands and manages software internally. Otherwise, it can cause problems.
Myth: Software can work right the first time
Reality: Not true. Software may have run time errors or anomalies that reduce reliability.
Myth: Increasing software reliability increases software safety
Reality: Much true that increased reliability increases security features and safety, but are not same.
Myth: Reusing software increases safety
Reality: Not always true. Reusability requires analysis during reuse.
Myth: Best software is one with more features
Reality: Not true. Other factors like reliability, security, flexibility, portability, and maintainability are also important.
Myth: Testing will remove all errors
Reality: Very true if testing is done in all phases (unit test, system test, acceptance test). Should be almost no
chance of errors at run time.
Myth: Once project is working, job is done
Reality: True if software is tested physically and logically and working properly. But continued support may be
needed.
1.1.5 Software Process Framework and Umbrella Activities
Definition: A software framework provides a standard way to build and deploy software product. It is a set of
activities and associated results that produce a software product.
Two Types of Activities in Software Process:
1. Framework Activities (Generic Activities): Always applicable to all projects. Include: Communication,
Planning, Modeling, Construction, Deployment.
2. Umbrella Activities: Non-SDLC activities applicable throughout the process, independent of framework activity.
Generic Framework Activities (Adaptable Process Model - APM):
• Communication: Software development starts with communication between customer and developer.
• Planning: Consists of complete estimation, scheduling for project development and tracking.
• Modeling: Complete requirement analysis and design of project like algorithm, flowchart etc.
• Construction: Code generation and testing. Coding implements design using programming language. Testing
checks coding flow correctness and if program provides desired output.
• Deployment: Delivering product to customer and taking feedback. If corrections or additional capabilities needed,
changes required for quality improvement.
Umbrella Activities (Typical Categories):
Software project tracking and control: Enables timely completion of SE tasks.
Formal technical review (FTR): Reviews techniques used in the project.
Software quality assurance (SQA): Very important for quality measurement of each software part.
Software configuration management (SCM): Set of activities to control changes by identifying work products
likely to change and establishing relationships.
Document preparation and production: Project planning and activities are documented for future reference.
Reusability management: Backing up software project parts for corrections, support, or software upgrades.
Measurement (estimation): Measurement/estimation of software project aspects like time, cost estimation etc.
Risk management: Identifies potential problems and deals with them when easier. Early identification provides
management decisions and improves product quality.
This summary provides a comprehensive overview of the fundamentals of software development, covering definitions,
characteristics, engineering approaches, and practical process frameworks used in modern software projects.