Assam ASSEB HS Multimedia and Web Technology cheat sheet

Multimedia = integration of text, graphics, audio, video and animation under interactive user control; linear multimedia plays without navigation, non-linear (interactive) multimedia responds to user input.

Classification by delivery: stand-alone (offline, e.g. CD/DVD/kiosk) versus networked (online, streamed over a network); hypermedia is non-linear multimedia whose elements are linked.

File-size estimate for uncompressed audio: size (bytes) = sample rate × bit depth ÷ 8 × channels × duration in seconds; halving sample rate or bit depth halves size.

Image memory formula: bytes = width × height × colour depth (bits) ÷ 8; a 1024×768 image at 24-bit colour needs 1024×768×3 = 2,359,296 bytes ≈ 2.25 MiB.

Frame-based animation size: total = frames × per-frame size; PAL video 25 fps, NTSC 30 fps (29.97), cinema film 24 fps - frame rate below about 16 fps reads as jerky.

Authoring tool categories: card/page-based (HyperCard-style stacks), icon/event-based (flowchart of icons, e.g. Authorware-style), time-based (timeline of layers, e.g. Director/Flash-style), and web authoring tools.

Compression is lossless (RLE, ZIP, PNG, GIF) when decoded data must equal the original, and lossy (JPEG, MP3, MPEG) when perceptual redundancy is discarded for a much smaller file.

Bandwidth rule: transmission time = file size ÷ bit rate; a 4 MB file over a 512 kbps link takes 4×8×1024×1024 ÷ 512000 ≈ 65 s, ignoring overhead.

Multimedia hardware roles: capture (camera, microphone, scanner), storage (large disk, adequate RAM for buffering), display/output (monitor, speakers) and processing (GPU/CPU for codecs).

Raster (bitmap) images store a colour value per pixel and degrade on scaling; vector images store geometric primitives and scale without pixelation but cannot represent photographic detail efficiently.

Colour models: RGB additive for screens (0–255 per channel), CMYK subtractive for print, HSV/HSL for intuitive hue-based selection; 24-bit true colour = 16,777,216 colours.

Resolution rules: PPI is for print, DPI for printer output, and pixel dimensions govern screen size; changing resolution while holding pixel dimensions changes physical print size, not detail.

Common formats: JPEG (lossy, photos, no transparency), PNG (lossless, alpha transparency), GIF (256 colours, animation, 1-bit transparency), SVG (XML vector), TIFF (lossless, print).

Selection and masking: marquee for geometric shapes, lasso for freehand, magic wand/quick selection by colour similarity, and layer masks for non-destructive hiding of pixels.

Layer model: opacity, blend mode, layer order and adjustment layers determine the composite; flattening merges layers permanently and discards editability.

Animation types: frame-by-frame (each frame drawn), keyframe/tweened (interpolated in-between frames), path animation, and procedural/scripted animation; onion skinning shows adjacent frames for reference.

Timeline concepts: frame rate, keyframe, tween span, layer, symbol/instance and loop; easing changes interpolation speed at the ends of a tween.

Colour depth and palette: 1-bit = 2 colours, 8-bit = 256 colours, 24-bit = 16.7 million; indexed-colour formats such as GIF are limited to a 256-entry palette.

Digital audio parameters: sample rate (CD = 44.1 kHz, DVD/video = 48 kHz), bit depth (16-bit CD), and channels (mono = 1, stereo = 2); Nyquist rule requires sample rate ≥ 2× highest frequency, so 44.1 kHz captures up to ~20 kHz.

Uncompressed audio bit rate = sample rate × bit depth × channels; CD stereo = 44100 × 16 × 2 = 1,411,200 bps ≈ 1.41 Mbps.

Audio formats: WAV/AIFF uncompressed PCM, MP3 and AAC lossy perceptual codecs, FLAC/ALAC lossless compression, MIDI as control data (notes, not sound).

Video = sequence of frames plus synchronised audio; container (MP4, AVI, MKV, WebM) wraps codecs (H.264, H.265, VP9, AAC, MP3) - container and codec are different concepts.

Uncompressed video bit rate = width × height × colour depth × frame rate; 1920×1080 at 24-bit and 25 fps = 1920×1080×24×25 ≈ 1.24 Gbps, which is why compression is mandatory.

Interlacing vs progressive: interlaced fields (1080i) refresh alternate lines; progressive (1080p) draws full frames; 720p/1080p are HD, 2160p is UHD/4K.

Sampling and quantisation: sampling discretises time (sample rate), quantisation discretises amplitude (bit depth); more levels reduce quantisation noise.

Editing workflow: capture/import, arrange on timeline, trim, add transitions/effects, mix audio levels to avoid clipping (0 dBFS ceiling), then export with target codec, bit rate and resolution.

Streaming needs buffering and adaptive bit rate; progressive download plays from a partially downloaded file, while true streaming delivers data continuously from a streaming server.

Internet vs WWW: the Internet is the global network of networks (TCP/IP), the World Wide Web is a hypertext service running on it via HTTP/HTTPS.

Protocol roles: IP for addressing/routing, TCP for reliable ordered delivery, UDP for low-latency unreliable delivery, HTTP/HTTPS for web transfer, FTP for file transfer, SMTP for sending mail, POP3/IMAP for retrieving mail, DNS for name-to-IP resolution.

URL anatomy: scheme://host:port/path?query#fragment - e.g. https://example.com:443/docs/page.html?id=7#top.

HTTP is stateless request-response: methods GET (retrieve, data in URL), POST (submit, data in body), PUT, DELETE; status codes 200 OK, 301 Moved Permanently, 404 Not Found, 500 Internal Server Error.

DNS resolution order: browser/OS cache → recursive resolver → root → TLD → authoritative nameserver, returning an A (IPv4) or AAAA (IPv6) record; TTL controls caching.

IP addressing: IPv4 is 32-bit dotted decimal, IPv6 is 128-bit hexadecimal; private ranges 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 are not routable on the public Internet.

Client-server vs peer-to-peer: client-server centralises resources and control; P2P distributes them among peers; a web browser is the client and the web server hosts resources.

Web evolution: Web 1.0 static read-only pages, Web 2.0 user-generated and interactive content, Web 3.0 semantic/decentralised ideas; intranet is private, extranet extends to partners.

Document skeleton: , , (meta charset, title, link, style, script) and ; is required and appears in the browser tab.</p>

Semantic structure elements: header, nav, main, section, article, aside, footer, figure/figcaption - preferred over generic divs for accessibility and SEO.

Text elements: h1–h6 (one h1 per page recommended), p, br (line break), hr, strong (importance) vs b (styling), em vs i, blockquote, pre, code.

Lists: ul (unordered), ol (ordered, with type/start/reversed), dl with dt and dd; lists may nest only inside li.

Links: with absolute, relative, root-relative or fragment (#id) targets; target="_blank" should be paired with rel="noopener".

Images and media: - alt is mandatory for accessibility; , , for multiple formats, for embedding.

Tables are for tabular data: table, caption, thead, tbody, tfoot, tr, th (scope), td; colspan and rowspan merge cells; never use tables for page layout.

Forms:

HTML5 input validation attributes (required, pattern, min, max, maxlength) enforce rules client-side but must be repeated server-side; deprecated presentational tags (font, center) are replaced by CSS.

Cascade precedence (high to low): !important author declarations, inline style, author stylesheet, user stylesheet, browser default; at equal origin and specificity the later rule wins.

Specificity score (a,b,c): a = IDs, b = classes/attributes/pseudo-classes, c = elements/pseudo-elements; inline styles outrank selectors and * has zero specificity.

Box model: content → padding → border → margin; box-sizing: border-box makes declared width include padding and border, avoiding layout surprises.

Display values: block (full width, new line), inline (flows in text, width/height ignored), inline-block, none (removed from layout) versus visibility: hidden (space retained).

Positioning: static (default), relative (offset from normal position), absolute (nearest positioned ancestor), fixed (viewport), sticky (toggles on scroll); z-index orders positioned elements.

Flexbox: display:flex on the container, main axis by flex-direction, justify-content aligns on main axis, align-items on cross axis, flex-grow/shrink/basis size items.

Grid: display:grid with grid-template-columns/rows, gap, and fr units; grid is two-dimensional, flexbox is primarily one-dimensional.

Responsive design: viewport meta tag, fluid widths in %, relative units (rem, em, vw), media queries @media (max-width: 768px), and mobile-first min-width queries.

Colour and typography: hex #RRGGBB, rgb()/rgba(), hsl(); font-family fallback stacks; rem is relative to root font size, em to the parent element's font size.

JavaScript is an interpreted, dynamically typed, prototype-based language executed by the browser; it manipulates the DOM but cannot by itself access server files or databases.

Variable declarations: var (function-scoped, hoisted, redeclarable), let (block-scoped, reassignable), const (block-scoped, no reassignment); prefer let/const.

Types: number (all numerics, IEEE-754 double), string, boolean, null, undefined, symbol, bigint, object; typeof null returns "object"; == coerces types, === does not.

Functions: declarations are hoisted, function expressions are not; arrow functions inherit this lexically and cannot be used as constructors.

DOM selection and change: document.getElementById, querySelector/querySelectorAll, element.textContent, innerHTML, style.property, classList.add/remove/toggle, setAttribute.

Events: addEventListener(type, handler) with event types click, submit, input, change, load, keydown; event.preventDefault() stops default behaviour, stopPropagation() halts bubbling.

Objects and arrays: object literals {key: value}, array methods push/pop/slice/splice/map/filter/forEach; JSON.parse and JSON.stringify convert between text and objects.

Asynchronous patterns: setTimeout/setInterval for timers, callbacks, Promises (then/catch/finally), async/await with try/catch; fetch() returns a Promise resolving to a Response.

Error handling and debugging: try/catch/finally, throw new Error(), console.log/warn/error, breakpoints and the browser DevTools console and Sources panel.

Hosting types: shared (many sites on one server), VPS (virtualised slice), dedicated (whole server), cloud (elastic resources), plus free static hosts; choice depends on traffic, control and budget.

Publishing steps: register a domain, point DNS records (A for IPv4, AAAA for IPv6, CNAME alias, MX mail, TXT verification) at the host, upload files via FTP/SFTP or Git, then test.

FTP uses ports 20/21 and is plaintext; SFTP runs over SSH (port 22) and FTPS adds TLS - credentials must never travel unencrypted.

HTTPS = HTTP over TLS on port 443 (HTTP is port 80); TLS provides confidentiality, integrity and server authentication via certificates from a CA such as Let's Encrypt.

Common attacks: SQL injection (parameterise queries), XSS (escape output, Content-Security-Policy), CSRF (tokens, SameSite cookies), clickjacking (X-Frame-Options), and brute force (rate limiting, strong passwords).

Password storage uses salted one-way hashes (bcrypt/Argon2), never plaintext or unsalted MD5; sessions should use HttpOnly, Secure, SameSite cookies.

Server-side validation is mandatory because client-side checks can be bypassed; file uploads need type/size checks and storage outside the web root.

Backups follow the 3-2-1 rule (3 copies, 2 media, 1 off-site); uptime is quoted in nines - 99.9% allows about 43 minutes of downtime per month.

Directory permissions follow least privilege: files 644, directories 755 on Linux; never leave directory listing or default admin pages enabled.

Practical exam pattern typically covers a multimedia authoring task (image/audio/video/animation edit) and a web task (HTML+CSS+JavaScript page), each assessed on correctness, design and documentation.

Project file structure convention: index.html at root, css/ for stylesheets, js/ for scripts, images/ and media/ for assets, with relative paths so the site runs from any folder.

Marking rubrics reward valid HTML (semantic tags, alt text), external CSS, working interactivity, responsiveness, and freedom from broken links or console errors.

Viva questions commonly test definitions (raster vs vector, lossy vs lossless, GET vs POST, id vs class), tag/attribute recall, and justification of design choices in the submitted project.

Documentation should state aim, tools and versions used, features implemented, screenshots, test cases with expected and actual results, and known limitations.

Testing checklist: validate markup with W3C validator, check links, test in at least two browsers, resize for mobile widths, confirm form validation messages and image alt text.

Deployment for a project demo uses a static host or free subdomain; upload all assets, verify case-sensitive filenames on Linux servers, and confirm HTTPS loads without mixed-content warnings.

Time management in the practical: plan the layout on paper first, build structure before styling, then add behaviour; keep a working copy before risky edits.