NSSCAS Computer Science (8231) cheat sheet

1 byte = 8 bits; 1 KiB = 1024 bytes; 1 MiB = 1024 KiB; 1 GiB = 1024 MiB; storage products may use decimal powers.

Denary to binary: repeated division by 2, read remainders bottom-up; binary to denary: sum place values 128,64,32,16,8,4,2,1 for 8 bits.

Hexadecimal: group binary bits in fours from the right; each nibble maps to 0-9 or A-F; useful shorthand for memory addresses and colour codes.

Unsigned n-bit range is 0 to 2^n - 1; two's complement n-bit range is -2^(n-1) to 2^(n-1) - 1; -x is invert bits of x plus 1.

Binary subtraction via two's complement: A - B = A + (-B); discard carry beyond fixed width; overflow occurs if operands have same sign and result sign differs.

BCD stores each decimal digit in a nibble; 39 decimal = 0011 1001; BCD is not pure binary and is less space efficient.

ASCII uses 7-bit codes for 128 characters; extended ASCII uses 8-bit codes for 256; Unicode uses code points and supports multiple scripts.

Lossless compression is reversible and preserves all data (RLE, Huffman); lossy compression permanently removes detail (JPEG, MP3) and suits human perception.

Uncompressed bitmap size in bits = width in pixels × height in pixels × colour depth in bits per pixel, plus header overhead; sound size = sample rate × bit depth × duration × channels.

OSI layers: Physical, Data Link, Network, Transport, Session, Presentation, Application; TCP/IP maps roughly to Link, Internet, Transport, Application.

TCP is connection-oriented, reliable, ordered and retransmits lost segments; UDP is connectionless, has no delivery guarantee, lower overhead and suits streaming or DNS.

IPv4 addresses are 32 bits; IPv6 addresses are 128 bits; private IPv4 ranges are 10/8, 172.16/12 and 192.168/16.

Circuit switching reserves a path for the call duration; packet switching routes independent packets with headers, sharing links and producing variable latency.

CSMA/CD detects collisions on wired Ethernet; CSMA/CA avoids collisions on Wi-Fi using acknowledgements and inter-frame spacing.

A MAC address is a 48-bit hardware address; an IP address is logical and routable; ARP resolves an IPv4 address to a MAC address on the local network.

Bandwidth is channel capacity in bits per second; latency is delay; throughput is actual achieved data rate; higher bandwidth does not always reduce latency.

Client-server centralises resources and control; peer-to-peer shares directly among nodes and can be resilient but is harder to manage and secure.

DNS maps domain names to IP addresses; DHCP automatically assigns IP configuration such as address, subnet mask, gateway and DNS server.

Von Neumann architecture stores instructions and data in the same memory and transfers both over common buses; Harvard architecture uses separate instruction and data paths.

Fetch-decode-execute: PC holds next address; MAR receives address; memory returns instruction to MDR; CIR holds instruction; PC increments; decode then execute.

The ALU performs arithmetic and logic; the control unit coordinates operations; registers include PC, MAR, MDR, CIR, ACC and status flags.

Performance depends on clock speed, cycles per instruction, cache size and hit rate, number of cores and pipelining; pipelining overlaps stages but hazards cause stalls.

RAM is volatile and directly accessible; ROM is non-volatile; cache is fast SRAM near the CPU; DRAM needs refresh; virtual memory uses disk when RAM is full.

RISC uses simpler fixed-length instructions, many registers and pipelining; CISC uses complex variable-length instructions and microcode; neither is fastest for every workload.

Input devices convert physical signals to digital data; output devices convert digital data to human-usable form; analogue sensors require an ADC.

Embedded systems are dedicated-function computers with processor, memory and I/O, often with real-time constraints; interrupts trigger ISRs asynchronously.

Address bus width determines maximum addressable memory; data bus width determines bits transferred per operation; control bus carries read/write and timing signals.

Operating system roles include process scheduling, memory management, file management, device management, security, user interface and error handling.

Scheduling: FCFS is simple but can cause convoy effect; SJF minimises average waiting time but needs burst estimates; round robin is fair with a time quantum; priority scheduling can starve.

Paging divides memory into fixed-size pages and frames with a page table; segmentation uses variable logical segments; virtual memory maps pages to disk.

Interrupt handling saves context, runs the interrupt service routine and restores context; polling repeatedly checks device status and wastes CPU compared with interrupts.

A compiler translates the whole source program to object code before execution; an interpreter executes line by line; an assembler translates assembly to machine code.

A linker combines object modules and libraries; a loader places an executable in memory; static linking copies libraries while dynamic linking loads them at run time.

Utility software performs maintenance such as backup, compression, antivirus scanning, defragmentation and disk cleanup; it is not application software.

A device driver translates operating-system commands into device-specific signals; virtual machine software emulates hardware and can host multiple guest operating systems.

CIA triad: confidentiality prevents unauthorised disclosure; integrity prevents unauthorised alteration; availability ensures timely access; authentication verifies identity and authorisation controls actions.

Symmetric encryption uses one shared secret key and is fast; asymmetric encryption uses a public/private key pair; hashing is one-way and checks integrity rather than providing encryption.

A digital signature encrypts a message hash with the sender's private key; the receiver verifies it with the sender's public key, giving authenticity and integrity.

Threats include phishing, pharming, malware, brute force, DDoS, SQL injection and social engineering; controls include MFA, patching, firewalls and input validation.

A firewall filters packets by rules; a proxy hides internal clients; a VPN encrypts traffic over untrusted networks; an IDS detects suspicious activity.

Backup supports recovery; archiving retains records; RAID improves availability but is not a backup against deletion, corruption or malware.

Integrity controls include validation checks such as range, type, length, format and presence, plus verification, access control and audit logs.

Data protection principles commonly require lawful and fair processing, purpose limitation, data minimisation, accuracy, storage limitation, integrity/confidentiality and accountability.

Copyright protects original expression such as text, music, code or images, not the underlying idea; a software licence defines permitted copying, modification and distribution.

Patents protect novel inventions or processes for a limited term; trademarks protect brand identifiers; these are distinct intellectual property rights.

Data protection law commonly gives rights such as access, correction and erasure, and requires fair, secure processing with limited retention.

Computer misuse legislation criminalises unauthorised access, unauthorised modification and unauthorised access with intent to commit further offences; exact names vary by country.

Plagiarism is presenting others' work as one's own; citation and licensing avoid it; copyright infringement is a legal issue, while plagiarism is an ethical or academic issue.

The digital divide is unequal access to technology caused by cost, infrastructure and skills; automation can displace jobs while creating new roles.

Algorithmic bias arises from unrepresentative data or flawed objectives; mitigation includes diverse data, testing and human review.

Professional codes require competence, honesty, confidentiality, avoiding conflicts of interest, and considering public safety and privacy.

A relational table has rows as records and columns as fields; a primary key uniquely identifies a row; a foreign key references a primary key and enforces referential integrity.

Relationships are one-to-one, one-to-many or many-to-many; a many-to-many relationship requires a junction table with foreign keys to both entities.

Normalisation: 1NF removes repeating groups; 2NF removes partial dependencies on a composite key; 3NF removes transitive dependencies.

SQL query form: SELECT fields FROM table WHERE condition GROUP BY fields HAVING condition ORDER BY fields; DML includes INSERT, UPDATE and DELETE; DDL includes CREATE, ALTER and DROP.

A JOIN combines rows by matching keys; INNER JOIN returns only matches; LEFT JOIN returns all left-table rows plus matching right-table rows.

A DBMS provides data independence, concurrent access, backup and recovery, access control and query optimisation; flat files risk redundancy and inconsistency.

Validation checks data entry by type, range, presence, length or format; verification checks transfer or copy accuracy using methods such as double entry.

An index speeds searches on a column but uses storage and slows INSERT and UPDATE operations; it does not change the logical data model.

An algorithm must be finite, unambiguous and effective; pseudocode and flowcharts express logic independently of a specific programming language.

Linear search is O(n); binary search is O(log n) and requires sorted data, repeatedly halving the search interval.

Bubble sort compares adjacent pairs and is O(n^2); insertion sort builds a sorted section and is O(n^2); merge sort divides then merges and is O(n log n).

A stack is LIFO with push and pop; a queue is FIFO with enqueue and dequeue; a linked list uses pointers and allows dynamic size but not direct index access.

Recursion needs a base case and a recursive case; each call uses stack space, so deep recursion can overflow; iteration often uses constant extra space.

Abstraction removes unnecessary detail; decomposition splits a problem into subproblems; pattern recognition identifies repeated structures that guide algorithm design.

Trace tables record variable values after each step; dry runs find logic errors; test data includes normal, boundary, invalid and extreme values.

Big-O gives an upper growth bound as input size increases; constants and lower-order terms are ignored; common orders include O(1), O(log n), O(n), O(n log n) and O(n^2).

A local variable is accessible inside its block or procedure; a global variable is accessible across the program; excessive globals increase unintended coupling and side effects.

Data types include integer, real, Boolean, character and string; strong typing catches type errors at compile time; casting converts between compatible types.

An array stores fixed-size elements of the same type accessed by index; one-dimensional and two-dimensional arrays exist; bounds checking prevents out-of-range access.

A record groups related fields of different types; a class defines attributes and methods; an object is an instance of a class; encapsulation hides internal state.

Stack operations are LIFO; queue operations are FIFO; a dictionary or map stores key-value pairs with fast lookup; a set stores unique elements.

A function returns a value; a procedure performs actions; pass by value copies data; pass by reference passes an address so changes affect the caller.

String operations include length, substring, concatenation, search and conversion; character codes allow comparison and manipulation.

File handling uses open, read or write, and close; text files store characters; binary files store raw bytes; closing flushes buffered data.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.

Waterfall is sequential with fixed requirements; iterative and incremental models deliver in cycles; Agile uses short iterations and frequent feedback.

Functional requirements state what the system does; non-functional requirements cover performance, security, usability and reliability; feasibility includes technical, economic, legal and operational checks.

Design tools include structure charts, flowcharts, pseudocode, wireframes and UML class or use-case diagrams; each models a different view of the system.

Testing levels are unit, integration, system and acceptance; black-box testing checks behaviour; white-box testing checks internal paths; regression retests after changes.

Verification asks whether the product was built correctly against the specification; validation asks whether it is the right product for user needs.

Maintenance types are corrective, adaptive, perfective and preventive; maintenance often consumes more lifecycle cost than initial development.

Version control tracks changes, supports branching and merging, and enables rollback; code review and documentation improve maintainability.

Deployment strategies include direct changeover, parallel running, phased conversion and pilot running; parallel running is safer but costly; pilot limits risk to a group.