Dara (Developer)

Dara (Developer)

hi

compscicompscicompsciii

Dara.

lets see

Software Engineering — Complete Exam Answers CSS That Shouldn't Exist

Trick 01

Wave Text

Each letter has animation-delay staggered by 0.08s. Hover a letter to snap it up. Pure CSS — just nth-child delays.

CSS  IS  WILD.

Trick 02

Neon Flicker

text-shadow stacked 4 layers deep creates the glow. The flicker is a keyframe that suddenly drops the shadow and darkens the color — like a real tube light.

OPEN 24HRS
NO VACANCY
DARA.DEV

Trick 03

Matrix Rain

20 absolutely positioned columns of text, each with a different animation-duration and animation-delay. They loop from top: -100% to top: 110%.

ア イ ウ エ オ カ キ ク ケ コ サ シ ス セ ソ タ チ ツ テ ト ナ ニ ヌ ネ ノ 1 0 1 1 0 0 1
0 1 カ キ 1 0 ア ク ケ 1 コ 0 サ シ ス 1 0 セ ソ タ チ ツ 1 テ ト 0 1 ナ ニ 0
ス セ ソ 1 0 タ チ 0 1 ツ テ ト 0 ナ ニ ヌ 1 ネ 0 ノ ア 1 イ ウ エ 0 1 オ カ キ
1 0 ア 1 イ ウ 0 エ 1 オ カ 0 キ ク 1 ケ 0 コ サ 1 シ ス 0 セ 1 ソ 0 タ チ 1
ネ ノ 0 1 ア イ 0 ウ エ 1 オ 0 カ キ ク 1 ケ コ 0 サ シ 1 ス セ ソ 0 タ チ 1 ツ
1 0 1 ア イ ウ エ オ 0 カ 1 キ ク ケ コ 0 サ シ 1 ス セ 0 ソ タ チ 1 ツ テ ト ナ
キ ク ケ コ 1 0 サ シ ス 1 セ ソ 0 タ チ ツ 1 テ ト ナ 0 ニ ヌ ネ ノ 1 ア 0 イ ウ
0 1 テ ト 0 ナ ニ 1 ヌ ネ ノ 0 ア 1 イ ウ エ 0 オ 1 カ キ ク ケ 0 コ サ 1 シ ス
ア 1 0 イ ウ エ オ カ キ ク 0 ケ コ 1 サ シ ス セ 0 ソ 1 タ チ ツ テ ト 0 ナ ニ ヌ
1 ネ ノ 0 ア 1 イ ウ 0 エ オ カ 1 キ ク ケ 0 コ サ 1 シ ス セ 0 ソ タ 1 チ ツ テ
セ ソ タ 0 1 チ ツ テ ト 0 ナ ニ 1 ヌ ネ ノ 0 ア イ ウ 1 エ オ 0 カ キ ク 1 ケ コ
0 ア 1 イ ウ エ 0 オ カ キ ク 1 ケ コ サ 0 シ ス セ ソ 1 タ チ ツ 0 テ ト ナ 1 ニ
ニ ヌ ネ 0 ノ ア 1 イ ウ エ オ 0 カ キ 1 ク ケ コ サ 0 シ ス セ 1 ソ タ チ ツ 0 テ
1 0 サ シ ス 1 セ ソ 0 タ チ 1 ツ テ ト 0 ナ ニ ヌ 1 ネ ノ ア イ 0 ウ エ オ 1 カ
ウ エ オ 0 カ 1 キ ク ケ コ サ 0 シ ス 1 セ ソ タ 0 チ ツ テ ト 1 ナ ニ ヌ 0 ネ ノ
0 1 ト ナ ニ 0 ヌ ネ ノ 1 ア イ ウ 0 エ オ カ 1 キ ク 0 ケ コ サ シ 1 ス セ ソ タ
タ チ 0 ツ テ ト 1 ナ ニ ヌ 0 ネ ノ ア 1 イ ウ エ オ 0 カ キ ク 1 ケ コ サ シ 0 ス
1 イ ウ エ 0 オ カ キ ク 1 ケ コ サ シ 0 ス セ ソ タ 1 チ ツ テ ト ナ 0 ニ ヌ ネ 1
コ サ シ 1 ス セ ソ 0 タ チ ツ テ 1 ト ナ ニ 0 ヌ ネ ノ ア 1 イ ウ エ 0 オ カ キ ク
0 テ ト 1 ナ ニ ヌ ネ 0 ノ ア イ 1 ウ エ オ カ 0 キ ク ケ コ 1 サ シ ス セ 0 ソ タ
Wake up, Dara.

Trick 04

Morphing Blobs

The border-radius property accepts 8 values (4 horizontal / 4 vertical). Animating between them creates the organic morph. The glow behind is a filter: blur() ::before pseudo-element.

Blue / Purple
Pink / Orange
Green / Cyan

Trick 05

Holographic Card

A conic-gradient overlay animates across the card. The sparkles are radial-gradient dots at different background-positions. Move your mouse over it.

4729 8831 0042 1337
Dara · Developer

Trick 06

Live CSS Variables

Clicking a swatch sets --td-accent on the card element via JavaScript. Every property referencing var(--td-accent) updates instantly — border, glow, text, bar.

Accent Color
The entire card — border, glow, title text, and this bar — all read from one CSS variable.
Change it once → everything updates. This is why CSS variables are powerful for theming.

Trick 07

CSS Typewriter

width: 0 animated with steps() — not ease, not linear, but steps — which makes it snap character by character. The blinking cursor is a border-right that blinks.

I write code.
I break things beautifully.
I study OS at 2am.
I make CSS do the impossible._

Trick 08

Text Stroke

-webkit-text-stroke draws an outline on the text. Combined with color: transparent you get hollow text. The bottom one uses a ::before with animating width to "fill" it.

HOLLOW
GRADIENT
FILLING...

Trick 09

CSS Starfield

Three layers of radial-gradient dots at 1–3px, each drifting at a different speed — creating parallax depth. Shooting stars are long thin divs with opacity animation.

somewhere in the universe · pure css

That's 9 tricks

Still going.

CSS can also do: parallax, custom checkboxes, accordion menus,
animated SVG paths, custom scrollbars, container queries, has() selector magic...
the rabbit hole goes very deep.

📚 Exam Preparation Guide

Software Engineering

UNITS I – V  ·  Complete Long Answers  ·  2026

I

Introduction to Software Engineering

10 Questions Covered

Q1 Explain Software Engineering Layered Technology with Diagram ▾

Software engineering is a layered technology that rests on a quality focus. Every layer supports all layers above it.

┌─────────────────────────────────────────────────────────┐ │ TOOLS │ ← Automated tools (CASE tools, IDEs) ├─────────────────────────────────────────────────────────┤ │ METHODS │ ← How-to techniques (design, coding, testing) ├─────────────────────────────────────────────────────────┤ │ PROCESS │ ← Framework for delivering software ├─────────────────────────────────────────────────────────┤ │ A QUALITY FOCUS (Foundation) │ ← Commitment to quality at every step └─────────────────────────────────────────────────────────┘

Layer Descriptions

  • Quality Focus: The foundation. It drives the culture of continuous improvement and produces software that meets user needs reliably.
  • Process Layer: Defines the framework — phases, deliverables, milestones, and quality assurance checkpoints. Examples: Waterfall, Agile, Spiral.
  • Methods Layer: Provides technical know-how for analysis, design, coding, testing, and maintenance.
  • Tools Layer: Provides semi-automated or automated support for process and methods. E.g., Visual Studio, JIRA, Selenium.
Q2 Discuss Software Development Life Cycle (SDLC) ▾

SDLC is a systematic process for planning, creating, testing, and delivering software. It provides a well-structured flow of phases to ensure quality and correctness of the final product.

Phases of SDLC

  1. Planning: Define scope, cost estimation, feasibility analysis, and resource allocation.
  2. Requirements Analysis: Gather and document functional and non-functional requirements from stakeholders.
  3. System Design: Convert requirements into architecture — HLD (High Level Design) and LLD (Low Level Design).
  4. Implementation (Coding): Developers write code based on design documents using chosen language/tools.
  5. Testing: Verify and validate the system (unit, integration, system, acceptance testing).
  6. Deployment: Release the product to the production environment.
  7. Maintenance: Fix bugs, add features, improve performance post-deployment.
Key SDLC Models: Waterfall, Iterative, Spiral, Agile, V-Model, Big Bang.
Q3 Explain Waterfall Model with Advantages & Disadvantages ▾

The Waterfall model is a linear-sequential life cycle model where each phase must be completed before the next begins, with no overlap.

[Requirements] ↓ [System Design] ↓ [Implementation] ↓ [Integration & Testing] ↓ [Deployment] ↓ [Maintenance]

Advantages

  • Simple and easy to understand and manage.
  • Phases are clearly defined with specific deliverables.
  • Works well for small projects with clear requirements.
  • Easy to measure progress through milestones.
  • Extensive documentation maintained at every stage.

Disadvantages

  • Not suitable for complex or long-duration projects.
  • Difficult to accommodate changing requirements midway.
  • Testing only begins after development is complete — late bug discovery.
  • No working software until late in the lifecycle.
  • Risk of requirement misunderstanding is high.
Q4 Explain Spiral Model with Risk Analysis ▾

The Spiral model, proposed by Barry Boehm (1988), combines the iterative nature of prototyping with the systematic aspects of the Waterfall model. It emphasizes risk analysis.

Plan → Risk Analysis ↑ ↓ Evaluate ← Engineering (Next Spiral)

Four Quadrants of Each Spiral

  1. Planning: Determine objectives, alternatives, and constraints.
  2. Risk Analysis: Identify and resolve risks (the most critical phase). Prototyping is used here.
  3. Engineering: Develop and test the product of that iteration.
  4. Evaluation: Customer evaluates the output and plans for next iteration.

Risk Analysis in Spiral

Risk is identified at every loop. If risk cannot be resolved, the project may be terminated early to avoid costly failure. This makes the Spiral model ideal for large, high-risk, mission-critical projects.

Advantages

  • Best for large, complex projects with high risk.
  • Continuous risk management at every phase.
  • Allows for customer feedback in each iteration.
  • Combines prototyping and systematic approach.

Disadvantages

  • Costly model — not suitable for small projects.
  • Risk analysis requires highly specific expertise.
  • Number of stages unknown in advance.
Q5 Compare Waterfall vs Agile Model ▾
ParameterWaterfallAgile
ApproachSequential, linearIterative, incremental
FlexibilityRigid — changes not welcomedHighly flexible to change
DeliverySingle final deliveryIncremental working software
Customer InvolvementOnly at start and endContinuous collaboration
TestingAfter development phaseThroughout every sprint
DocumentationExtensiveMinimal, just enough
Best ForSmall, well-defined projectsDynamic, evolving projects
RiskHigh (late testing)Low (continuous testing)
Q6 Explain Agile Methodology Principles ▾

Agile is an iterative software development approach based on the Agile Manifesto (2001), which values:

Individuals & Interactions over processes and tools
Working Software over comprehensive documentation
Customer Collaboration over contract negotiation
Responding to Change over following a plan

12 Principles of Agile

  1. Customer satisfaction through early and continuous delivery.
  2. Welcome changing requirements, even late in development.
  3. Deliver working software frequently (weeks, not months).
  4. Business people and developers must work together daily.
  5. Build projects around motivated individuals.
  6. Face-to-face conversation is the best form of communication.
  7. Working software is the primary measure of progress.
  8. Agile promotes sustainable development.
  9. Continuous attention to technical excellence.
  10. Simplicity — maximizing work NOT done.
  11. Self-organizing teams produce best architectures.
  12. Regular reflection on how to become more effective.

Popular Agile frameworks: Scrum, Kanban, XP (Extreme Programming), SAFe.

Q7 What are Software Myths? Explain Types ▾

Software myths are misleading beliefs and attitudes about software and the software development process that cause project failures.

1. Management Myths

  • "We have a book full of standards — that's enough." (Standards ≠ quality practice)
  • "Adding more people to a late project will speed it up." (Brook's Law: adding manpower to a late project makes it later.)
  • "We have the tools and computers, so we have everything." (Tools alone do not produce quality software.)

2. Customer Myths

  • "A general statement of objectives is sufficient to start writing programs." (Vague requirements lead to failures.)
  • "Software requirements continually change, but change can be easily accommodated." (Changes have significant cost and time impact.)

3. Practitioner Myths

  • "Once we write the program and get it to work, our job is done." (Maintenance takes 60-80% of effort.)
  • "Quality can be checked in by testing." (Quality must be built in from the start.)
  • "Until the program runs, there is no way to assess its quality." (Reviews and inspections are equally effective.
Q8 Explain Process Framework Activities (Umbrella Activities) ▾

Framework Activities (Core)

  1. Communication: Understand objectives and gather requirements from stakeholders.
  2. Planning: Define tasks, schedule, resources, risk assessment.
  3. Modeling: Create models to understand requirements and design.
  4. Construction: Code generation and testing.
  5. Deployment: Deliver and get feedback.

Umbrella Activities (Applied throughout all phases)

  • Software project tracking and control
  • Risk management
  • Software quality assurance (SQA)
  • Technical reviews
  • Measurement
  • Software configuration management (SCM)
  • Reusability management
  • Work product preparation and production
Umbrella activities are cross-cutting concerns that ensure software quality, tracking, and management across all phases of the process framework.
Q9 What is CMMI (Capability Maturity Model Integration)? ▾

CMMI is a process improvement framework developed by the Software Engineering Institute (SEI), Carnegie Mellon. It defines the maturity of an organization's software processes across 5 levels.

CMMI 5 Maturity Levels

LevelNameDescription
1InitialProcesses are unpredictable, poorly controlled and reactive.
2ManagedProjects are planned, performed, measured and controlled.
3DefinedOrganization-wide standards for processes are documented.
4Quantitatively ManagedProcesses are controlled using statistical and quantitative techniques.
5OptimizingContinuous process improvement through innovation and feedback.

CMMI helps organizations improve process performance, reduce defects, and deliver software on schedule and budget. It is used during appraisals to rate an organization's capability.

Q10 Evolution of Software Engineering ▾
EraPeriodKey Features
First Generation1950s–60sBatch processing, assembly language, no formal methods, single user.
Second Generation1960s–70sMulti-user systems, time-sharing, database systems, "Software Crisis" emerged.
Third Generation1970s–90sDistributed computing, OOP, structured programming, CASE tools.
Fourth Generation1990s–2000sClient-server, the Internet, component-based software, web applications.
Fifth Generation2000s–nowMobile, cloud computing, AI/ML integration, microservices, DevOps, Agile.
The Software Crisis (1960s) was a major turning point — projects were running over budget, over schedule, and delivering unreliable software, which led to the formal birth of Software Engineering as a discipline (NATO Conference, 1968).
II

Software Requirements

10 Questions Covered

Q1 Explain Functional vs Non-Functional Requirements ▾

Functional Requirements (FR)

Functional requirements describe what the system should do — the functions, features, and behaviors of the system.

  • User login and authentication
  • Process payment transactions
  • Generate sales reports
  • Send email notifications

Non-Functional Requirements (NFR)

NFRs describe how the system should perform — quality attributes, constraints, and system properties.

TypeExample
PerformanceSystem must respond within 2 seconds
SecurityData must be encrypted using AES-256
ReliabilitySystem uptime must be 99.9%
ScalabilityMust handle 10,000 concurrent users
UsabilityInterface must be learnable in 30 min
PortabilityRun on Windows, Linux, and macOS
Q2 Explain Software Requirement Specification (SRS) ▾

An SRS is a formal document that describes the intended behavior of a software system. It serves as a contract between customer and developer.

Structure of SRS (IEEE 830)

  1. Introduction (purpose, scope, definitions)
  2. Overall Description (product perspective, functions, user characteristics)
  3. Specific Requirements (functional, non-functional, interface requirements)
  4. Appendices and Index

Characteristics of a Good SRS

  • Correct: Every requirement is accurately stated.
  • Unambiguous: Each requirement has only one interpretation.
  • Complete: All relevant requirements are included.
  • Consistent: No conflicting requirements.
  • Verifiable: Requirements can be tested.
  • Modifiable: Easy to change in a structured way.
  • Traceable: Each requirement can be traced to its origin.
Q3 Explain Requirements Engineering Process ▾

Requirements Engineering (RE) is the process of defining, documenting, and maintaining requirements. It involves the following systematic activities:

[Feasibility Study] → [Elicitation] → [Analysis] → [Specification] → [Validation] → [Management]
  1. Feasibility Study: Determine if the system is technically, financially, and operationally feasible.
  2. Requirements Elicitation: Gather requirements from stakeholders using interviews, questionnaires, observation, prototyping, etc.
  3. Requirements Analysis: Analyze for completeness, conflicts, and ambiguity. Build domain models.
  4. Requirements Specification: Document the requirements clearly in an SRS.
  5. Requirements Validation: Verify the SRS is correct, consistent, and complete via reviews or prototyping.
  6. Requirements Management: Track and control changes to requirements throughout the project.
Q4 Explain Requirements Elicitation Techniques ▾

Requirements Elicitation is the process of discovering requirements from various sources — stakeholders, users, existing documents.

Techniques

  • Interviews: Direct Q&A with stakeholders. Can be structured (fixed questions) or unstructured (open-ended).
  • Questionnaires/Surveys: Collect data from many users simultaneously. Cost-effective for large groups.
  • Observation: Analyst observes users performing tasks to understand implicit requirements.
  • Brainstorming: Group discussion to generate ideas and requirements freely.
  • Prototyping: Build a rough model; user feedback on prototype reveals hidden requirements.
  • Use Case Analysis: Identify actors and use cases to model system interactions.
  • JAD (Joint Application Development): Structured workshops with developers and users together.
  • Document Analysis: Review existing systems, forms, and reports.
Q5 Explain Feasibility Study (Technical, Economic, Operational) ▾

A feasibility study evaluates whether a proposed system is viable before committing resources.

Types of Feasibility

  • Technical Feasibility: Can the system be built with available technology, hardware, and software? Examines technical complexity, availability of tools, and team expertise.
  • Economic (Financial) Feasibility: Is the project worth the investment? Involves cost-benefit analysis, ROI calculation, and budget estimation. Uses techniques like NPV, IRR, Payback Period.
  • Operational Feasibility: Will the system work in the organization's current environment? Considers user acceptance, training needs, management support, and workflow changes.
  • Legal Feasibility: Does the system comply with laws and regulations (GDPR, copyright, etc.)?
  • Schedule Feasibility: Can the system be delivered within the required timeframe?
Output of feasibility study: a Feasibility Report that recommends whether to proceed, modify, or abandon the project.
Q6 Explain Requirements Validation & Verification ▾

Requirements Validation

"Are we building the RIGHT system?" — Ensures the SRS accurately reflects the customer's needs.

  • Conducted with stakeholders and customers.
  • Techniques: Reviews, walkthroughs, prototyping, test case generation.

Requirements Verification

"Are we building the system RIGHT?" — Checks consistency, completeness, and correctness of requirements.

  • Done internally by the development team.
  • Techniques: Formal inspections, checklists, model checking.
AspectValidationVerification
FocusCustomer needsSpecifications correctness
Done byCustomers + DevelopersDevelopment team
QuestionRight product?Product right?
Q7 Explain Requirements Management ▾

Requirements Management is the process of managing changes to requirements during the software development lifecycle. It ensures that changes are controlled, traceable, and consistent.

Key Activities

  • Change Control: Formal process to request, evaluate, approve, or reject changes.
  • Requirements Traceability: Track each requirement from origin through design, implementation, and testing (forward and backward traceability).
  • Version Control: Maintain versions of the SRS document.
  • Impact Analysis: Assess how a change in one requirement affects others.
  • Status Tracking: Monitor each requirement's status (proposed, approved, implemented, tested).
A Requirements Traceability Matrix (RTM) is a key tool used to map requirements to design, test cases, and code modules.
Q8 What are User vs System Requirements? ▾
AspectUser RequirementsSystem Requirements
DefinitionHigh-level descriptions of what the user needs from the systemDetailed specifications of system functions, services, and constraints
Written forNon-technical customers/usersDevelopers and technical staff
LanguageNatural language, simpleStructured, technical notation
Example"The system should allow users to search for books""The system shall search the catalog by ISBN, title, or author and return results within 1 second"
LevelAbstract/High-levelDetailed/Low-level
Q9 Write Short Notes on Interface Requirements ▾

Interface requirements define how the software system interacts with other systems, hardware, or users. There are four types:

  • User Interface (UI) Requirements: Define the look, feel, and interaction of the system with end-users. E.g., "The system shall use a web-based GUI with responsive design."
  • Hardware Interface Requirements: Describe how software interacts with physical devices. E.g., "The system must communicate with a barcode scanner via USB."
  • Software Interface Requirements: Define interactions with other software components, APIs, or OS. E.g., "The system shall use REST APIs to communicate with the payment gateway."
  • Communication Interface Requirements: Specify network protocols and communication standards. E.g., "All data transmission shall use HTTPS/TLS 1.3."
Q10 Problems in Requirements Engineering ▾
  • Incomplete Requirements: Stakeholders don't mention all needs, often because they assume them as obvious.
  • Ambiguous Requirements: Unclear language leads to different interpretations by developers and customers.
  • Inconsistent Requirements: Conflicting needs from different stakeholders.
  • Changing Requirements: Business needs evolve, making initial requirements outdated.
  • Communication Gaps: Misunderstanding between technical and non-technical stakeholders.
  • Requirement Creep (Scope Creep): Continuous addition of new requirements without proper control.
  • Implicit Requirements: Requirements that stakeholders assume don't need to be stated.
  • Conflicting Priorities: Different stakeholders prioritize different features.
Studies show that over 50% of software project failures are due to poor requirements engineering.
III

Design Engineering & UML

10 Questions Covered

Q1 Explain Design Process & Design Concepts ▾

Software design is the process of transforming requirements into a blueprint for constructing the software. It is a creative activity that defines the architecture, components, interfaces, and data of the system.

Design Process

  1. Data/Class Design: Transform analysis model into data structures needed to implement the software.
  2. Architectural Design: Define relationships among major structural elements.
  3. Interface Design: Describe how the software communicates internally and externally.
  4. Component-Level Design: Transform structural elements into procedures/algorithms.

Fundamental Design Concepts

  • Abstraction: Suppress detail at different levels (procedural, data abstraction).
  • Modularity: Divide software into independently addressable components.
  • Information Hiding: Modules should hide internal details, exposing only interfaces.
  • Cohesion: Degree to which elements within a module belong together (high is good).
  • Coupling: Degree of interdependence between modules (low is good).
  • Refinement: Stepwise refinement — progressively elaborate design.
  • Refactoring: Reorganize code to reduce complexity without changing behavior.
Q2 Explain Software Architecture & Architectural Styles ▾

Software architecture is the high-level structure of a software system, defining how components interact to fulfill system requirements.

Common Architectural Styles

  • Layered (N-tier): System organized into layers (Presentation → Business Logic → Data). E.g., web applications.
  • Client-Server: Clients request services from a centralized server. E.g., email systems.
  • MVC (Model-View-Controller): Separates application into Model (data), View (UI), Controller (logic). E.g., Django, Rails.
  • Microservices: Application as a collection of small, independently deployable services. E.g., Netflix, Amazon.
  • Event-Driven: Components communicate through events/messages. E.g., IoT systems, UI frameworks.
  • Pipe and Filter: Data flows through a sequence of processing components. E.g., UNIX shell pipelines, compilers.
  • Repository (Blackboard): Multiple components share a central data store. E.g., databases.
Q3 Explain Cohesion and Coupling ▾

Cohesion

Cohesion is the measure of how strongly related the functions within a module are. High cohesion is desirable.

TypeDescription (Low → High)
CoincidentalElements grouped arbitrarily (lowest)
LogicalElements perform similar logical operations
TemporalElements executed at the same time
ProceduralElements follow a specific sequence
CommunicationalElements operate on same data
SequentialOutput of one is input to next
FunctionalAll elements contribute to one single function (highest)

Coupling

Coupling is the degree of interdependence between modules. Low coupling is desirable.

TypeDescription (High → Low)
Content CouplingModule directly accesses another's internal data (worst)
Common CouplingModules share global data
Control CouplingOne module passes control information to another
Stamp CouplingModules share composite data structures
Data CouplingModules share only necessary data via parameters (best)
Q4 Draw and Explain Class Diagram ▾

A Class Diagram is a structural UML diagram that shows the static structure of a system by depicting classes, their attributes, methods, and relationships.

┌──────────────────┐ ┌──────────────────┐ │ Person │ │ Course │ ├──────────────────┤ ├──────────────────┤ │ - name: String │ │ - courseId: int │ │ - age: int │ │ - title: String │ ├──────────────────┤ enrolls├ - credits: int │ │ + getName() │─────────├──────────────────┤ │ + setName() │ 1 * │ + getTitle() │ └──────────────────┘ └──────────────────┘ △ │ (inheritance) ┌──────────────────┐ │ Student │ ├──────────────────┤ │ - studentId: int │ │ - grade: float │ ├──────────────────┤ │ + getGrade() │ └──────────────────┘

Class Diagram Relationships

  • Association: "uses a" — basic relationship between classes.
  • Aggregation: "has a" — whole-part (part can exist independently).
  • Composition: "contains a" — strong ownership (part cannot exist without whole).
  • Inheritance/Generalization: "is a" — subclass inherits from superclass.
  • Dependency: One class uses another temporarily.
  • Realization: Class implements an interface.
Q5 Draw and Explain Sequence Diagram ▾

A Sequence Diagram is a behavioral UML diagram that shows how objects interact in a time-ordered sequence. It captures the dynamic behavior of a use case.

:User :LoginPage :AuthService :Database | | | | |--login()----->| | | | |--authenticate()| | | | |---queryUser()->| | | |<--userData----| | |<--authToken---| | |<--success-----| | |

Key Elements

  • Actors/Objects: Represented as boxes at the top.
  • Lifelines: Dashed vertical lines representing object's lifetime.
  • Activation Bar: Thin rectangle on lifeline showing active execution.
  • Messages: Horizontal arrows — synchronous (filled arrowhead), asynchronous (open arrowhead), return (dashed arrow).
  • Time flows downward.
Q6 Use Case Diagram — Library & Online Shopping System ▾

Library Management System

[Librarian] [Member] | | ┌────┴───────────────────┴──────────────────┐ │ Library Management System │ │ (Add Book) (Remove Book) (Search Book) │ │ (Issue Book)──────────────────────────────│ │ (Return Book) (View Fine) (Reserve Book) │ └────────────────────────────────────────────┘

Online Shopping System

[Customer] [Admin] | | ┌────┴─────────────────────┴──────────────────┐ │ Online Shopping System │ │ (Browse Products) (Add to Cart) │ │ (Checkout) (Make Payment) ──── [PayGateway] │ │ (Track Order) (Write Review) │ │ (Manage Products) (Manage Orders) [Admin] │ └──────────────────────────────────────────────┘

Use Case Diagram Elements

  • Actor: External entity that interacts with system (stick figure).
  • Use Case: Function the system provides (oval).
  • System Boundary: Rectangle containing all use cases.
  • «include»: A use case always includes another.
  • «extend»: A use case optionally extends another.
Q7 Explain Component Diagram ▾

A Component Diagram shows the physical and logical components of a system and their dependencies. It depicts how the system is split into components and how they interact.

┌──────────────┐ ┌─────────────────┐ ┌──────────────┐ │ UI Component│───>│ Business Logic │───>│ Database │ │ (Web/Mobile)│ │ (Application) │ │ Component │ └──────────────┘ └─────────────────┘ └──────────────┘ │ ┌───────┴──────────┐ │ Auth Component │ └──────────────────┘

Key Elements

  • Component: A modular unit with well-defined interfaces (rectangle with component icon ⊞).
  • Interface: Provided interface (lollipop symbol) and Required interface (socket symbol).
  • Dependency: Dashed arrow showing one component depends on another.

Component diagrams are used for large system decomposition, visualizing the distribution of functionality, and planning reuse.

Q8 Explain Collaboration Diagram ▾

A Collaboration Diagram (also called a Communication Diagram in UML 2.x) shows how objects interact structurally — it emphasizes the organization/structure of objects, unlike sequence diagrams which emphasize time order.

┌──────────┐ 1: login() ┌────────────┐ │ :User │──────────────>│ :LoginCtrl │ └──────────┘ └────────────┘ │ 2: authenticate()│ ▼ ┌────────────┐ │:AuthService│ └────────────┘

Key Characteristics

  • Objects shown as rectangles connected by links (associations).
  • Messages labeled with sequence numbers (1, 2, 2.1 for nested calls).
  • Same information as a Sequence Diagram but different layout — focuses on structure over time.
  • Useful for visualizing which objects are connected and how many messages are passed.
Q9 Architectural Design vs Detailed Design ▾
AspectArchitectural Design (HLD)Detailed Design (LLD)
LevelHigh-LevelLow-Level
FocusSystem structure, major components and their interactionInternal logic of each component/module
OutputArchitecture document, block diagramsData structures, algorithms, pseudo-code
Done bySenior architectsDevelopers/designers
UML DiagramsPackage, Component, Deployment diagramsClass, Sequence, Collaboration diagrams
ChangesVery costly to changeLess costly to change
Q10 Explain Conceptual Model of UML ▾

UML (Unified Modeling Language) is a standardized graphical language for visualizing, specifying, constructing, and documenting software systems. It was developed by Grady Booch, James Rumbaugh, and Ivar Jacobson (the "Three Amigos") and standardized by OMG.

UML Building Blocks

1. Things (Vocabulary)

  • Structural: Class, Interface, Component, Node
  • Behavioral: Use case, interaction, state machine
  • Grouping: Package
  • Annotational: Notes/Comments

2. Relationships

  • Dependency, Association, Aggregation, Composition, Generalization, Realization

3. Diagrams

Structural (Static)Behavioral (Dynamic)
Class, Object, Component, Deployment, PackageUse Case, Sequence, Collaboration, State, Activity
IV

Testing & Metrics

9 Questions Covered

Q1 Explain Software Testing Strategies ▾

A testing strategy integrates test case design methods into a well-planned series of steps. Testing proceeds from unit to integration to system to acceptance.

[ Unit Testing ] → [ Integration Testing ] → [ System Testing ] → [ Acceptance Testing ]

Levels of Testing

  • Unit Testing: Tests individual modules/functions in isolation. Done by developers. Uses white-box techniques.
  • Integration Testing: Tests combined modules to verify interfaces. Approaches: Big Bang, Top-Down, Bottom-Up, Sandwich.
  • System Testing: Tests complete, integrated system against requirements. Black-box testing. Includes functional and non-functional testing.
  • Acceptance Testing (UAT): Validates system meets user expectations before delivery. Done by customers.
  • Regression Testing: Retest after changes to ensure nothing is broken.
  • Alpha Testing: Internal testing at developer site.
  • Beta Testing: External testing by actual users in real environment.
Q2 Explain Black-box & White-box Testing Techniques ▾

Black-Box Testing (Functional Testing)

Tests software without knowledge of internal code structure. Focus: what the system does.

Techniques

  • Equivalence Partitioning: Divide input into valid and invalid classes; test one value per class.
  • Boundary Value Analysis (BVA): Test at the edges of input ranges (min, max, min-1, max+1).
  • Decision Table Testing: Test combinations of conditions and their actions.
  • State Transition Testing: Test transitions between states.
  • Use Case Testing: Test based on use case scenarios.

White-Box Testing (Structural Testing)

Tests software with full knowledge of internal structure. Focus: how the system does it.

Techniques

  • Statement Coverage: Every statement executed at least once.
  • Branch Coverage (Decision Coverage): Every branch (true/false) taken at least once.
  • Path Coverage: Every possible path through code executed.
  • Condition Coverage: Every boolean sub-expression evaluated to both true and false.
  • Loop Testing: Test loops at zero, one, and many iterations.
Q3 Differentiate Black-box vs White-box Testing ▾
ParameterBlack-Box TestingWhite-Box Testing
Also Known AsFunctional / Behavioral TestingStructural / Glass-box Testing
Knowledge RequiredNo internal code knowledgeFull code knowledge required
FocusInputs and outputsCode structure, logic, paths
Done ByTesters/QA teamDevelopers
TechniqueEquivalence partitioning, BVABranch coverage, path testing
CoversFunctional requirementsCode implementation
Suitable ForSystem, Acceptance TestingUnit, Integration Testing
LimitationCannot test internal pathsCannot test missing functionality
Q4 Explain Unit, Integration, System Testing ▾

Unit Testing

Tests the smallest testable unit of software (a function, method, or class) in isolation from the rest.

  • Done by developers during coding phase.
  • Uses stubs (simulate called modules) and drivers (simulate calling modules).
  • Primarily white-box testing.
  • Tools: JUnit, NUnit, PyTest.

Integration Testing

Tests interfaces and interaction between integrated units/modules.

  • Big Bang: All modules combined at once and tested.
  • Top-Down: Test from top-level modules downward, using stubs.
  • Bottom-Up: Test from lowest-level modules upward, using drivers.
  • Sandwich: Combination of top-down and bottom-up.

System Testing

Tests the completely integrated system to verify it meets specified requirements.

  • Black-box testing approach.
  • Includes: Functional, Performance, Security, Stress, Load, Usability testing.
  • Done by independent testing team.
Q5 Explain Debugging Process / Art of Debugging ▾

Debugging is the process of finding and fixing the cause of a known bug. It begins after testing reveals a failure.

[Test Reveals Failure] → [Locate Cause] → [Fix Defect] → [Re-test] → [Pass?]

Debugging Strategies

  • Brute Force: Add print statements everywhere. Inefficient but commonly used.
  • Backtracking: Start at failure point and trace backwards through code.
  • Cause Elimination: Hypothesize a cause, design tests to confirm/deny.
  • Program Slicing: Focus only on the code slice relevant to the failing variable.

Debugging Tools

IDE debuggers (breakpoints, watchpoints, call stack inspection), memory leak detectors, log analyzers.

The "Art" of debugging lies in forming good hypotheses and systematically eliminating possibilities — not in randomly modifying code.
Q6 Explain Validation vs Verification ▾
AspectVerificationValidation
DefinitionAre we building the product right?Are we building the right product?
FocusProcess conformance to specificationsProduct meets user needs
TypeStatic activity (reviews, inspections)Dynamic activity (testing on software)
WhenDuring development phasesAt the end of development
Performed byQA team, developersTesting team with end-users
ExampleReviewing SRS, design, codeRunning acceptance tests
MethodsWalk-throughs, reviews, inspectionsBlack-box testing, UAT
Barry Boehm's definition: Verification = "Are we building it right?"; Validation = "Are we building the right thing?"
Q7 Explain Software Metrics ▾

Software metrics are quantitative measures of software products and processes. They provide objective data for project management and quality assessment.

Categories of Software Metrics

  • Size Metrics: LOC (Lines of Code), Function Points, Feature Points.
  • Complexity Metrics: Cyclomatic Complexity, Halstead complexity measures.
  • Quality Metrics: Defect density, Mean Time Between Failures (MTBF).
  • Productivity Metrics: LOC/person-month, Function Points/person-month.
  • Reliability Metrics: MTTF (Mean Time To Failure), failure rate.

GQM (Goal-Question-Metric) Paradigm

A framework to define metrics purposefully: Define a Goal → Ask Questions to meet the goal → Identify Metrics to answer those questions.

Q8 Explain Process vs Product Metrics ▾
AspectProcess MetricsProduct Metrics
DefinitionMeasure the software development process itselfMeasure characteristics of the software product
PurposeImprove process efficiency and qualityAssess product quality and characteristics
ExamplesDefect removal efficiency, review coverage, cost per LOCLOC, Function Points, Cyclomatic Complexity
FocusHow software is builtWhat is built
Used byProject managersDevelopers and QA

Why Metrics Matter

Software metrics help: estimate cost and schedule, assess process quality, identify risks early, compare alternatives, and provide basis for continual improvement.

Q9 Short Notes: Cyclomatic Complexity & Test Case Design ▾

Cyclomatic Complexity (McCabe's Metric)

Cyclomatic Complexity (CC) measures the number of linearly independent paths through a program's source code. It quantifies code complexity.

Formula: CC = E − N + 2P

  • E = Number of edges in the control flow graph
  • N = Number of nodes
  • P = Number of connected components (usually 1)
  • Also: CC = Number of decision points + 1
CC = 1–10: Simple, low risk
CC = 11–20: Moderate complexity
CC = 21–50: High risk, hard to test
CC > 50: Untestable, must refactor

Test Case Design

A test case is a set of conditions under which a tester determines if a system works correctly.

Components of a Test Case: Test Case ID, Description, Preconditions, Input Data, Steps, Expected Result, Actual Result, Status (Pass/Fail).

Good test case properties: Accurate, economical, traceable to requirements, repeatable, and likely to find defects.

V

Risk & Quality Management

9 Questions Covered

Q1 Explain Risk Management Process ▾

Risk management is the process of identifying, assessing, and controlling threats to a software project's success.

[Identify] → [Analyze] → [Prioritize] → [Plan] → [Resolve] → [Monitor]

Steps in Risk Management

  1. Risk Identification: Identify what could go wrong — technical, organizational, business, or people risks.
  2. Risk Analysis: Assess probability and impact of each risk. Risk Exposure = Probability × Impact.
  3. Risk Prioritization: Rank risks by their exposure. Focus on top risks first (top-10 risk list).
  4. Risk Planning (RMMM): Develop strategies to mitigate, monitor, and manage each risk.
  5. Risk Resolution: Execute the risk mitigation strategies.
  6. Risk Monitoring: Track risk indicators and reassess regularly throughout the project.
Q2 Explain Risk Identification, Projection, Refinement ▾

Risk Identification

Identify potential risks in the project. Types:

  • Generic Risks: Common to all software projects (requirement changes, budget overrun).
  • Product-Specific Risks: Risks specific to the technology or domain.
  • Risk items: Technology, people, resources, tools, schedule, customer requirements.

Risk Projection (Risk Estimation)

Assess each risk on two dimensions:

  • Probability: Likelihood (0–1 scale) that risk will occur.
  • Impact: Severity of consequences (catastrophic, critical, marginal, negligible).
  • Risk Exposure (RE) = Probability × Impact cost.

Risk Refinement

Break down compound risks into sub-risks for finer analysis. Uses a condition-transition-consequence (CTC) triplet: "Given condition C, if situation S occurs, then consequence X may result."

Q3 Explain RMMM (Risk Mitigation, Monitoring, Management) ▾

RMMM is a risk strategy plan that addresses each significant risk through three activities:

Risk Mitigation

Proactive steps to reduce probability or impact of a risk before it occurs.

  • Example: High staff turnover risk → mitigate by documenting thoroughly, cross-training team members.
  • Strategies: Avoid, Transfer, Reduce, Accept.

Risk Monitoring

Tracking risk indicators during the project to detect if a risk is occurring.

  • Define trigger conditions (risk symptoms).
  • Regular risk reviews at project milestones.

Risk Management

Contingency plans — actions to take when a risk actually occurs.

  • Develop a contingency plan in advance.
  • Assign a risk owner responsible for monitoring and response.
The RMMM plan is typically documented as part of the Software Project Plan.
Q4 Explain Software Quality Assurance (SQA) ▾

SQA is a planned, systematic set of activities that ensure the software development process and its products conform to established standards, processes, and procedures.

SQA Activities

  • Process Definition: Establish standards, procedures, guidelines.
  • Audits: Periodic review of software process and product compliance.
  • Technical Reviews: Walkthroughs, inspections to detect defects early.
  • Testing: Multi-level testing strategy execution.
  • Error Cause Analysis: Identify root causes of defects and prevent recurrence.
  • Metrics Collection: Track quality indicators across the project.
  • Record Keeping: Document all findings for continuous improvement.

SQA vs Testing

SQA is process-focused (prevention), while testing is product-focused (detection). SQA ensures quality is built in; testing verifies quality is present.

Q5 Explain ISO 9000 Quality Standards ▾

ISO 9000 is a family of international quality management standards developed by the International Organization for Standardization (ISO).

Key Standards in the ISO 9000 Family

  • ISO 9000: Vocabulary and fundamentals of quality management systems.
  • ISO 9001: Requirements for a quality management system (most widely used). Organizations get certified to this standard.
  • ISO 9004: Guidelines for performance improvement.
  • ISO 9126: Software quality characteristics (functionality, reliability, usability, efficiency, maintainability, portability).

8 Principles of ISO 9001

  1. Customer Focus
  2. Leadership
  3. Involvement of People
  4. Process Approach
  5. System Approach to Management
  6. Continual Improvement
  7. Factual Approach to Decision Making
  8. Mutually Beneficial Supplier Relationships
Q6 Explain Software Reviews (Formal Technical Reviews) ▾

A Formal Technical Review (FTR) is a structured quality assurance activity performed by software engineers to detect errors in software work products.

Objectives of FTR

  • Uncover errors in function, logic, and implementation early.
  • Verify work product meets requirements and standards.
  • Make development consistent and manageable.
  • Produce deliverables that are more easily testable.

FTR Process

  1. Planning: Producer informs project leader. Materials distributed 1–2 days before.
  2. Preparation: Reviewers study the work product and note issues.
  3. Review Meeting: ≤2 hours. Recorder notes all issues. No problem solving during meeting.
  4. Post-Review: Produce review issues list. Producer fixes defects. Reviewers verify fixes.

Types of Reviews

  • Walk-through: Producer guides reviewers — informal, educational focus.
  • Inspection: Formal, systematic, checklist-based — highest defect detection rate.
  • Audit: Independent review for compliance to standards.
Q7 Explain Software Reliability ▾

Software reliability is the probability of failure-free software operation for a specified period of time in a specified environment.

Key Reliability Measures

  • MTTF (Mean Time To Failure): Average time between start and first failure.
  • MTTR (Mean Time To Repair): Average time taken to repair a failure.
  • MTBF (Mean Time Between Failures): MTTF + MTTR — average time between consecutive failures.
  • Availability: MTTF / (MTTF + MTTR) × 100%
  • Failure Rate (λ): Number of failures per unit time = 1/MTBF

Reliability Growth Models

Software reliability improves as bugs are found and fixed. Models like Jelinski-Moranda and Goel-Okumoto predict how reliability grows with testing time.

Q8 Discuss Reactive vs Proactive Risk Strategies ▾
AspectReactive StrategyProactive Strategy
DefinitionReact to risks when they occurIdentify and address risks before they occur
Also called"Fire fighting""Risk management"
TimingAfter problem occursBefore project begins and throughout
PlanningNo risk plan existsRMMM plan created in advance
CostHigher (crisis response is expensive)Lower (prevention cheaper than cure)
Project ImpactHigh schedule/budget impactMinimized impact through early action
Common inImmature organizations (CMMI Level 1)Mature organizations (CMMI Level 3+)
Best Practice: Always prefer proactive risk management. A proactive approach includes risk identification, risk analysis (RMMM), and regular risk monitoring throughout the SDLC.
Q9 What is Statistical Software Quality Assurance? ▾

Statistical Software Quality Assurance (SSQA) implies using statistical methods to systematically track, measure, and improve software quality by analyzing defect data.

Steps in SSQA

  1. Collect software error data for every project — categorize each defect by type, origin, and severity.
  2. Trace each error to its underlying cause (e.g., inadequate testing, poor design).
  3. Identify the "vital few" causes responsible for the most defects (Pareto Principle — 80% of defects come from 20% of causes).
  4. Fix the most impactful causes first.
  5. Improve the process to eliminate the root causes.

Statistical Tools Used

  • Pareto Charts: Identify most common defect causes.
  • Control Charts: Monitor process stability over time.
  • Histograms: Show distribution of defect types.
  • Cause-and-Effect (Fishbone) Diagrams: Root cause analysis.
  • Six Sigma: Reduce defects to 3.4 per million opportunities.
SSQA underpins Total Quality Management (TQM) in software — moving from defect detection to defect prevention through data-driven decisions.
Pure CSS — How Far Can We Go
Pure HTML & CSS — No libraries

How Far
Can We Go?

Everything you see here — the glow, the 3D flip, the spinning borders, the glitch, the floating blobs — is just CSS. Zero JavaScript for visuals.

scroll

Glassmorphism

Cards with blur, transparency and mouse-tracking glow. The hover glow follows your cursor using a CSS trick with custom properties.

🧠
Machine Learning
Building models that learn from data to make predictions and decisions without explicit programming.
AI / ML
⚡
Web Performance
Optimizing load times, rendering, and runtime performance for fast, smooth user experiences.
Optimization
🔐
Cryptography
Protecting information through encryption, hashing, and digital signatures.
Security
📡
Networking
Protocols, routing, TCP/IP — how data travels across the internet and local networks.
Systems

Neon Spinning Borders

A conic-gradient rotates around the card border using @property — a newer CSS feature. No JS, no SVG, just a spinning gradient.

48
Questions covered
5
Units
100%
Pure HTML
0
Libraries used

3D Flip Cards

Hover to flip. This is pure CSS 3D — transform-style: preserve-3d and perspective. No JavaScript at all.

🌊
Waterfall Model

Linear, sequential phases. Each phase must finish before the next starts. Simple but rigid.

🔄
Agile Model

Iterative sprints with continuous feedback. Flexible to change. Best for evolving projects.

🌀
Spiral Model

Risk-driven iterations. Each loop: plan → risk analysis → build → evaluate. By Barry Boehm.

✅
V-Model

Each dev phase has a corresponding test phase. Verification + Validation at every step.

Animated Skill Bars

CSS animations triggered by an IntersectionObserver (3 lines of JS). The bars fill using scaleX transform — smoother than width animation.

HTML & CSS95%
JavaScript78%
Software Engineering90%
Data Structures85%
Operating Systems80%
Discrete Mathematics75%

Pure CSS Loaders

Five different loading animations. Spinners, orbits, bouncing dots, pulse rings, audio bars — all @keyframes, zero JS.

Spinner
Orbit
Bounce
Pulse
Audio

Gradient Text

background-clip: text with an animated background-position. The text itself is transparent — the gradient shows through.

Dara. Developer. CS Student.

Animated Timeline

A vertical line with pulsing glowing dots. Fully CSS — the glow uses box-shadow, the pulse uses @keyframes scale.

2022
Started Computer Science
Began the journey into algorithms, data structures, and the fascinating world of software engineering.
2023
First Web Project
Built a portfolio using pure HTML & CSS. Discovered that you don't always need a framework to make things look great.
2024
Deep Dive into OS & Networks
Studied process synchronization, memory management, file systems, and IPC mechanisms.
2026
Built an SE Exam Guide
Created a 48-question interactive study guide in pure HTML that looks this cool. Exam szn.

Floating Tags

Each tag bobs at a different speed using CSS animation-duration and animation-delay variables. Hover to see the glow effect.

HTML CSS JavaScript Python OS Algorithms Data Structures Networks Discrete Math Git Linux UML SQL SDLC