Language cheat sheets for HTML, CSS, JavaScript, React Native, Kotlin, and more — plus software development insights and source code guides.
Reuse TypeScript utility types: Partial, Required, Pick, Omit, Record, Readonly, Exclude, Extract, NonNullable, ReturnType, and Parameters. Keep this page open beside your editor.
Prep TypeScript interview questions: type vs interface, structural typing, never/unknown/any, narrowing, generics, and what the compiler erases at runtime.
Type React with TypeScript: props interfaces, children, useState inference, event types, refs, and why React.FC is optional in 2026. Keep this page open beside your editor.
Write reusable TypeScript with generics: type parameters, extends constraints, default types, infer in conditional types, and generic React/API helpers.
Model TypeScript shapes with types and interfaces: optional fields, readonly, unions, intersections, extends, and declaration merging you should not surprise-use.
A TypeScript cheat sheet for 2026: primitive types, interfaces, unions, generics, narrowing, and tsconfig flags you actually turn on in app code. Use it when syntax slips mid-task.
Choose the right Kotlin scope function: let, run, apply, also, and with — object vs result, this vs it, and the readable patterns that survive code review.
Start Kotlin with syntax that matters: val/var, types, if/when, functions, lists, null safety, and a tiny Android click handler you can type from memory.
Build Android UI with Jetpack Compose: @Composable functions, remember, mutableStateOf, Modifier, LazyColumn, and recomposition rules that keep lists smooth.
Model domain data with Kotlin data classes and sealed classes: copy, destructuring, equals, and exhaustive when branches for success/error UI state. Keep it beside your editor.
Write Kotlin functions with default and named arguments, lambdas, higher-order functions, trailing lambda syntax, and inline/reified when it actually helps.
Handle nulls in Kotlin without NPEs: nullable types, safe calls, elvis, let, requireNotNull, lateinit, and when !! is actually justified. Keep this page open beside your editor.
Prep Kotlin interview questions: null safety, data vs sealed classes, coroutines, object vs companion, and JVM interop — short answers with tiny code in your head.
Compare Kotlin vs Java for Android and JVM: null safety, data classes, coroutines vs verbose threads, and how to call Java from Kotlin without surprises.
Transform data with Kotlin collections: listOf vs mutableListOf, map, filter, groupBy, associate, and sequences for long lazy chains. Keep this page open beside your editor.
Run async Kotlin with coroutines: viewModelScope, launch vs async, Dispatchers, withContext, supervisorScope, and Flow for streams of values. Use it when syntax slips mid-task.
Build Android screens in Kotlin: activities, view binding, intents, the activity lifecycle, and the patterns that replace findViewById spaghetti. Use it when syntax slips mid-task.
Start React Native with a first screen: Expo setup, View/Text, props, useState, StyleSheet, and the mental shift from HTML/CSS to native components. Keep it beside your editor.
Render long lists in React Native with FlatList: data, renderItem, keyExtractor, extraData, infinite scroll, and the props that stop dropped frames. Keep it beside your editor.
Ship faster with Expo: create an app, app.json config, Expo Go vs dev builds, EAS Build/Submit, and when you still need a custom native module. Use it when syntax slips mid-task.
Debug React Native with logs, React DevTools, redboxes, network inspectors, Hermes, and list performance tools instead of guessing why a screen is blank.
Persist data and call APIs in React Native: AsyncStorage, fetch, FormData uploads, and the permission patterns that differ on iOS and Android. Use it when syntax slips mid-task.
Prep React Native interview questions: JS thread vs UI thread, FlatList, state, navigation, native modules, and how RN differs from React on the web. Keep it beside your editor.
Compare React Native vs Flutter: JavaScript vs Dart, native widgets vs a custom renderer, ecosystem, hiring, and which stack fits your team and product.
Style React Native apps with StyleSheet and Flexbox: column default, density-independent pixels, Platform.select, and the CSS properties that do not exist on native.
Manage React Native state with hooks: useState, useEffect, useRef, useMemo, useCallback, useWindowDimensions, and custom hooks that wrap device APIs. Keep it beside your editor.
Navigate screens in React Native with a stack and tabs: navigate, goBack, route params, headers, and deep linking patterns used with React Navigation.
Build screens from core React Native components: View, Text, Image, Pressable, TextInput, ScrollView, and the props you reach for instead of HTML tags.
Start JavaScript with the essentials: let and const, types, if/else, loops, functions, arrays, and how to connect a script to HTML without drowning in frameworks.
Call HTTP APIs with the Fetch API: GET/POST, JSON headers, FormData, CORS credentials, error handling, and AbortController cancellation. Keep this page open beside your editor.
Persist small client data with localStorage and sessionStorage: setItem, getItem, JSON serialization, expiry patterns, quotas, and when cookies or IndexedDB fit better.
Write JavaScript functions with clear scope: declarations vs expressions, arrows, default params, closures, this binding, and when an IIFE still makes sense.
Compare TypeScript vs JavaScript: what types catch, how tsc/bundlers compile, when JS is enough, and how to migrate a file at a time without stopping shipping.
Catch and throw errors in JavaScript: try/catch/finally, Error types, async rejections, optional chaining vs real checks, and user-facing messages that do not leak internals.
Handle dates in JavaScript with Date, ISO strings, timestamps, Intl.DateTimeFormat, and the timezone pitfalls that break “today” comparisons. Use it when syntax slips mid-task.
Handle clicks, input, and submit with JavaScript events: addEventListener, capture vs bubble, delegation, once, AbortController, and preventDefault vs stopPropagation.
Revise JavaScript interview questions: closures, this, hoisting, event loop, promises, prototypes, and === — short answers you can say while writing a tiny example.
Work with JavaScript objects and JSON: keys, destructuring, spread, optional chaining, structured clone, and safe parse/stringify for APIs and localStorage.
Write asynchronous JavaScript with promises and async/await: then/catch, parallel Promise.all, sequential awaits, and error handling around fetch. For real projects, not toy demos.
Use modern JavaScript (ES6+) daily: let and const, arrow functions, destructuring, spread, template literals, classes, and ES modules instead of var and globals.
Query and update the page with the JavaScript DOM: querySelector, createElement, textContent vs innerHTML, classList, and traversing parents and siblings safely.
Edit text with JavaScript string methods: slice, split, trim, includes, replace/replaceAll, pad, and template literals — plus Unicode caveats with length and emoji.
Transform lists with JavaScript array methods: map, filter, reduce, find, some, sort, slice, and the immutable patterns that keep React and Node code predictable.
Style interactive and structural states with CSS pseudo-classes: hover, focus-visible, nth-child, :not, :has, and form validity without extra JavaScript classes.
Measure CSS boxes correctly: content, padding, border, margin, box-sizing, outline vs border, and why 100% width plus padding overflows the parent. Keep it beside your editor.
Prep CSS interview questions on the box model, specificity, Flexbox vs Grid, positioning, and responsive units — short answers you can sketch on a whiteboard.
Compare Tailwind CSS vs plain CSS: utility classes, design tokens, @apply, when a custom stylesheet wins, and how to mix both without fighting specificity.
Theme and reuse values with CSS custom properties: --tokens on :root, var() fallbacks, scoped overrides, and dark mode without duplicating entire stylesheets.
Animate UI with CSS transitions and @keyframes: properties that interpolate, easing, duration, fill-mode, and which animations stay off the main thread.
Write responsive CSS with media queries: mobile-first min-width, prefers-reduced-motion, dark scheme, print, and container queries that react to a component’s width.
Place elements with CSS position: static flow, relative offsets, absolute containing blocks, fixed viewports, sticky headers, and the z-index stacking rules that go with them.
Target the right elements with CSS selectors: class, id, attribute, combinators, pseudo-classes, and the specificity rules that decide which declaration wins.
Build two-dimensional layouts with CSS Grid: template columns, rows, areas, gap, minmax, and auto-fit cards that collapse without extra media queries.
Lay out rows and columns with CSS Flexbox: flex-direction, justify-content, align-items, gap, wrapping, and the item properties that actually move boxes.
Ship maintainable HTML in 2026: valid document structure, semantic landmarks, accessible forms, honest meta tags, and performance-friendly images and scripts.
Embed video, audio, responsive images, and canvas in HTML: controls, tracks, picture/srcset, and the 2D canvas context you draw from JavaScript. Use it when syntax slips mid-task.
Start every HTML page from a valid boilerplate: doctype, lang, charset, viewport, title, and a header/main/footer skeleton you can paste into static sites or PHP views.
Revise HTML interview questions on semantic tags, forms, accessibility, meta, and the difference between block, inline, and replaced elements. Use it when syntax slips mid-task.
Compare HTML vs HTML5 in practice: the short doctype, semantic tags, native video/audio, form types, canvas, and APIs that replaced plugin-era markup.
Encode reserved HTML characters and common symbols with named or numeric entities: ampersand, quotes, nbsp, copyright, arrows, and when UTF-8 makes entities optional.
Make HTML usable with a keyboard and a screen reader: labels, alt text, headings, focus, and ARIA only when native HTML cannot express the same meaning.
Mark up data tables in HTML with caption, thead, tbody, th scope, colspan, and rowspan — plus when a table is the wrong tool compared with a list or definition list.
Set crawlable HTML meta tags: charset, viewport, title, description, canonical, robots, and Open Graph — the head snippet every public page needs in 2026.
Use HTML5 semantic tags instead of anonymous divs: header, nav, main, article, section, aside, and footer — plus when each landmark actually belongs on the page.
Build and validate HTML forms with this cheat sheet: input types, labels, GET vs POST, required fields, and the constraints browsers enforce before JavaScript.
Kotlin cheat sheet covering syntax, null safety, data classes, collections, coroutines, and the Android patterns you search for while building apps.
React Native cheat sheet for core components, styling, lists, navigation patterns, and hooks used to ship iOS and Android apps from one JavaScript codebase.
A JavaScript cheat sheet covering modern syntax, array methods, promises, DOM APIs, and the snippets developers search for while shipping features.
A CSS cheat sheet for selectors, the box model, Flexbox, Grid, units, and responsive media queries — the syntax developers search for daily.
A practical HTML cheat sheet covering document structure, semantic tags, forms, media, and the attributes you actually use in 2026.
Discover how purchasing production-ready source code can save months of development time and thousands of dollars for startups and businesses.
Explore the best final year project ideas for computer science students — from AI face recognition to e-commerce and healthcare systems.
A practical guide to selecting a software development partner — what to look for, red flags, and questions to ask.
Learn proven SEO strategies for software companies — technical SEO, content marketing, and AI search optimization (GEO).
Compare Laravel and plain PHP for web development projects — pros, cons, and when to use each for your business.
