hi
compscicompscicompsciii
lets see
Trick 01
Each letter has animation-delay staggered by 0.08s. Hover a letter to snap it up. Pure CSS — just nth-child delays.
Trick 02
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.
Trick 03
20 absolutely positioned columns of text, each with a different animation-duration and animation-delay. They loop from top: -100% to top: 110%.
Trick 04
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.
Trick 05
A conic-gradient overlay animates across the card. The sparkles are radial-gradient dots at different background-positions. Move your mouse over it.
Trick 06
Clicking a swatch sets --td-accent on the card element via JavaScript. Every property referencing var(--td-accent) updates instantly — border, glow, text, bar.
Trick 07
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.
Trick 08
-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.
Trick 09
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.
That's 9 tricks
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.
UNITS I – V · Complete Long Answers · 2026
10 Questions Covered
Software engineering is a layered technology that rests on a quality focus. Every layer supports all layers above it.
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.
The Waterfall model is a linear-sequential life cycle model where each phase must be completed before the next begins, with no overlap.
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.
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.
| Parameter | Waterfall | Agile |
|---|---|---|
| Approach | Sequential, linear | Iterative, incremental |
| Flexibility | Rigid — changes not welcomed | Highly flexible to change |
| Delivery | Single final delivery | Incremental working software |
| Customer Involvement | Only at start and end | Continuous collaboration |
| Testing | After development phase | Throughout every sprint |
| Documentation | Extensive | Minimal, just enough |
| Best For | Small, well-defined projects | Dynamic, evolving projects |
| Risk | High (late testing) | Low (continuous testing) |
Agile is an iterative software development approach based on the Agile Manifesto (2001), which values:
Popular Agile frameworks: Scrum, Kanban, XP (Extreme Programming), SAFe.
Software myths are misleading beliefs and attitudes about software and the software development process that cause project failures.
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.
| Level | Name | Description |
|---|---|---|
| 1 | Initial | Processes are unpredictable, poorly controlled and reactive. |
| 2 | Managed | Projects are planned, performed, measured and controlled. |
| 3 | Defined | Organization-wide standards for processes are documented. |
| 4 | Quantitatively Managed | Processes are controlled using statistical and quantitative techniques. |
| 5 | Optimizing | Continuous 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.
| Era | Period | Key Features |
|---|---|---|
| First Generation | 1950s–60s | Batch processing, assembly language, no formal methods, single user. |
| Second Generation | 1960s–70s | Multi-user systems, time-sharing, database systems, "Software Crisis" emerged. |
| Third Generation | 1970s–90s | Distributed computing, OOP, structured programming, CASE tools. |
| Fourth Generation | 1990s–2000s | Client-server, the Internet, component-based software, web applications. |
| Fifth Generation | 2000s–now | Mobile, cloud computing, AI/ML integration, microservices, DevOps, Agile. |
10 Questions Covered
Functional requirements describe what the system should do — the functions, features, and behaviors of the system.
NFRs describe how the system should perform — quality attributes, constraints, and system properties.
| Type | Example |
|---|---|
| Performance | System must respond within 2 seconds |
| Security | Data must be encrypted using AES-256 |
| Reliability | System uptime must be 99.9% |
| Scalability | Must handle 10,000 concurrent users |
| Usability | Interface must be learnable in 30 min |
| Portability | Run on Windows, Linux, and macOS |
An SRS is a formal document that describes the intended behavior of a software system. It serves as a contract between customer and developer.
Requirements Engineering (RE) is the process of defining, documenting, and maintaining requirements. It involves the following systematic activities:
Requirements Elicitation is the process of discovering requirements from various sources — stakeholders, users, existing documents.
A feasibility study evaluates whether a proposed system is viable before committing resources.
"Are we building the RIGHT system?" — Ensures the SRS accurately reflects the customer's needs.
"Are we building the system RIGHT?" — Checks consistency, completeness, and correctness of requirements.
| Aspect | Validation | Verification |
|---|---|---|
| Focus | Customer needs | Specifications correctness |
| Done by | Customers + Developers | Development team |
| Question | Right product? | Product right? |
Requirements Management is the process of managing changes to requirements during the software development lifecycle. It ensures that changes are controlled, traceable, and consistent.
| Aspect | User Requirements | System Requirements |
|---|---|---|
| Definition | High-level descriptions of what the user needs from the system | Detailed specifications of system functions, services, and constraints |
| Written for | Non-technical customers/users | Developers and technical staff |
| Language | Natural language, simple | Structured, 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" |
| Level | Abstract/High-level | Detailed/Low-level |
Interface requirements define how the software system interacts with other systems, hardware, or users. There are four types:
10 Questions Covered
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.
Software architecture is the high-level structure of a software system, defining how components interact to fulfill system requirements.
Cohesion is the measure of how strongly related the functions within a module are. High cohesion is desirable.
| Type | Description (Low → High) |
|---|---|
| Coincidental | Elements grouped arbitrarily (lowest) |
| Logical | Elements perform similar logical operations |
| Temporal | Elements executed at the same time |
| Procedural | Elements follow a specific sequence |
| Communicational | Elements operate on same data |
| Sequential | Output of one is input to next |
| Functional | All elements contribute to one single function (highest) |
Coupling is the degree of interdependence between modules. Low coupling is desirable.
| Type | Description (High → Low) |
|---|---|
| Content Coupling | Module directly accesses another's internal data (worst) |
| Common Coupling | Modules share global data |
| Control Coupling | One module passes control information to another |
| Stamp Coupling | Modules share composite data structures |
| Data Coupling | Modules share only necessary data via parameters (best) |
A Class Diagram is a structural UML diagram that shows the static structure of a system by depicting classes, their attributes, methods, and relationships.
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.
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.
Component diagrams are used for large system decomposition, visualizing the distribution of functionality, and planning reuse.
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.
| Aspect | Architectural Design (HLD) | Detailed Design (LLD) |
|---|---|---|
| Level | High-Level | Low-Level |
| Focus | System structure, major components and their interaction | Internal logic of each component/module |
| Output | Architecture document, block diagrams | Data structures, algorithms, pseudo-code |
| Done by | Senior architects | Developers/designers |
| UML Diagrams | Package, Component, Deployment diagrams | Class, Sequence, Collaboration diagrams |
| Changes | Very costly to change | Less costly to change |
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.
| Structural (Static) | Behavioral (Dynamic) |
|---|---|
| Class, Object, Component, Deployment, Package | Use Case, Sequence, Collaboration, State, Activity |
9 Questions Covered
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.
Tests software without knowledge of internal code structure. Focus: what the system does.
Tests software with full knowledge of internal structure. Focus: how the system does it.
| Parameter | Black-Box Testing | White-Box Testing |
|---|---|---|
| Also Known As | Functional / Behavioral Testing | Structural / Glass-box Testing |
| Knowledge Required | No internal code knowledge | Full code knowledge required |
| Focus | Inputs and outputs | Code structure, logic, paths |
| Done By | Testers/QA team | Developers |
| Technique | Equivalence partitioning, BVA | Branch coverage, path testing |
| Covers | Functional requirements | Code implementation |
| Suitable For | System, Acceptance Testing | Unit, Integration Testing |
| Limitation | Cannot test internal paths | Cannot test missing functionality |
Tests the smallest testable unit of software (a function, method, or class) in isolation from the rest.
Tests interfaces and interaction between integrated units/modules.
Tests the completely integrated system to verify it meets specified requirements.
Debugging is the process of finding and fixing the cause of a known bug. It begins after testing reveals a failure.
IDE debuggers (breakpoints, watchpoints, call stack inspection), memory leak detectors, log analyzers.
| Aspect | Verification | Validation |
|---|---|---|
| Definition | Are we building the product right? | Are we building the right product? |
| Focus | Process conformance to specifications | Product meets user needs |
| Type | Static activity (reviews, inspections) | Dynamic activity (testing on software) |
| When | During development phases | At the end of development |
| Performed by | QA team, developers | Testing team with end-users |
| Example | Reviewing SRS, design, code | Running acceptance tests |
| Methods | Walk-throughs, reviews, inspections | Black-box testing, UAT |
Software metrics are quantitative measures of software products and processes. They provide objective data for project management and quality assessment.
A framework to define metrics purposefully: Define a Goal → Ask Questions to meet the goal → Identify Metrics to answer those questions.
| Aspect | Process Metrics | Product Metrics |
|---|---|---|
| Definition | Measure the software development process itself | Measure characteristics of the software product |
| Purpose | Improve process efficiency and quality | Assess product quality and characteristics |
| Examples | Defect removal efficiency, review coverage, cost per LOC | LOC, Function Points, Cyclomatic Complexity |
| Focus | How software is built | What is built |
| Used by | Project managers | Developers and QA |
Software metrics help: estimate cost and schedule, assess process quality, identify risks early, compare alternatives, and provide basis for continual improvement.
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
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.
9 Questions Covered
Risk management is the process of identifying, assessing, and controlling threats to a software project's success.
Identify potential risks in the project. Types:
Assess each risk on two dimensions:
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."
RMMM is a risk strategy plan that addresses each significant risk through three activities:
Proactive steps to reduce probability or impact of a risk before it occurs.
Tracking risk indicators during the project to detect if a risk is occurring.
Contingency plans — actions to take when a risk actually occurs.
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 is process-focused (prevention), while testing is product-focused (detection). SQA ensures quality is built in; testing verifies quality is present.
ISO 9000 is a family of international quality management standards developed by the International Organization for Standardization (ISO).
A Formal Technical Review (FTR) is a structured quality assurance activity performed by software engineers to detect errors in software work products.
Software reliability is the probability of failure-free software operation for a specified period of time in a specified environment.
Software reliability improves as bugs are found and fixed. Models like Jelinski-Moranda and Goel-Okumoto predict how reliability grows with testing time.
| Aspect | Reactive Strategy | Proactive Strategy |
|---|---|---|
| Definition | React to risks when they occur | Identify and address risks before they occur |
| Also called | "Fire fighting" | "Risk management" |
| Timing | After problem occurs | Before project begins and throughout |
| Planning | No risk plan exists | RMMM plan created in advance |
| Cost | Higher (crisis response is expensive) | Lower (prevention cheaper than cure) |
| Project Impact | High schedule/budget impact | Minimized impact through early action |
| Common in | Immature organizations (CMMI Level 1) | Mature organizations (CMMI Level 3+) |
Statistical Software Quality Assurance (SSQA) implies using statistical methods to systematically track, measure, and improve software quality by analyzing defect data.
Everything you see here — the glow, the 3D flip, the spinning borders, the glitch, the floating blobs — is just CSS. Zero JavaScript for visuals.
Effect 01
Cards with blur, transparency and mouse-tracking glow. The hover glow follows your cursor using a CSS trick with custom properties.
Effect 02
A conic-gradient rotates around the card border using @property — a newer CSS feature. No JS, no SVG, just a spinning gradient.
Effect 03
Hover to flip. This is pure CSS 3D — transform-style: preserve-3d and perspective. No JavaScript at all.
Linear, sequential phases. Each phase must finish before the next starts. Simple but rigid.
Iterative sprints with continuous feedback. Flexible to change. Best for evolving projects.
Risk-driven iterations. Each loop: plan → risk analysis → build → evaluate. By Barry Boehm.
Each dev phase has a corresponding test phase. Verification + Validation at every step.
Effect 04
CSS animations triggered by an IntersectionObserver (3 lines of JS). The bars fill using scaleX transform — smoother than width animation.
Effect 05
Five different loading animations. Spinners, orbits, bouncing dots, pulse rings, audio bars — all @keyframes, zero JS.
Effect 06
background-clip: text with an animated background-position. The text itself is transparent — the gradient shows through.
Effect 07
A vertical line with pulsing glowing dots. Fully CSS — the glow uses box-shadow, the pulse uses @keyframes scale.
Effect 08
Each tag bobs at a different speed using CSS animation-duration and animation-delay variables. Hover to see the glow effect.