Glossary

Words to recognise

You don't need to memorise these. Recognise them when you read code, and open the topic when you need a reminder.

_layout: The file that wraps the screens in a folder, for example with a Stack or Tabs.; Screens and navigation
!: Not: flips true to false and false to true.; Making decisions with if
!==: Strictly not equal.; Making decisions with if
?: In a type, marks an optional property. In code, ?. reads a property only if the value exists.; Unions and optional values
? :: The ternary operator: condition ? valueIfTrue : valueIfFalse.; Showing things conditionally
.: Dot: reads or changes a property, like user.name.; Objects
..: "One folder up" from where you are.; Files, folders and paths The terminal, step by step
...: Spread: copies the items or properties of one array or object into a new one.; Objects Destructuring and spread
.js: The extension for JavaScript files.; Set up VS Code and Node
.ts: The extension for TypeScript files (.tsx when they contain JSX).; Why types catch bugs
() =>: An arrow function with no parameters, often used inline: onClick={() => setCount(0)}.; Events in React
(tabs): A folder name in brackets groups screens without adding to the URL.; Tabs
[ ]: Square brackets: make an array, or read an item, like names[0].; Arrays
[]: An empty array.; filter and find
[count, setCount]: The state value and its setter, unpacked from useState.; State with useState
{ }: Curly braces: a block of code, or an object.; Scope
@ts-ignore: A comment that hides the error on the next line. Avoid it; fix the cause instead.; Reading type errors
/: Separates folders in a path. On its own at the start, it means the top of the drive.; Files, folders and paths
&&: And: true only when both sides are true.; Making decisions with if Showing things conditionally
+: Adds numbers, but joins strings. "5" + 1 gives "51".; Strings and numbers
<li>: A list item element, usually inside <ul> or <ol>.; Lists and keys
=: Assignment: put the value on the right into the name on the left. Not "equals".; Values and variables
===: Strictly equal: same value and same type. Use this one.; Making decisions with if
=>: Arrow: a short way to write a function, like n => n * 2.; Functions in, values out Arrays and mapfilter and findArrow functions
>=: Greater than or equal to.; Making decisions with if
|: In TypeScript types: or. In JavaScript, || is the or operator.; Unions and optional values
||: Or: true when at least one side is true.; Making decisions with if
~: Short for your home folder.; The terminal, step by step
${}: Puts a value inside a template literal: `Hi ${name}`.; Strings and numbers
200: Status code for "OK, here it is".; What happens when you open a URL
404: Status code for "not found".; What happens when you open a URL
AAB: Android App Bundle: the file you upload to Google Play.; Building a release with EAS
absolute path: A path from the very top of the drive, like /Users/rafi/notes. Works from anywhere.; Files, folders and paths
absolute position: position: "absolute" places a view at exact left/top/bottom values.; The game loop
accumulator: The running result inside reduce, like a running total.; reduce
ActivityIndicator: A spinning loading circle in React Native.; Calling an API
actual: What really happened. The gap between expected and actual is the bug.; Using AI as a study partner
adaptive icon: An Android icon in two layers that the phone shapes into a circle, square and so on.; Icons, names and screenshots
addEventListener: Tells an element which function to run when an event happens.; Events and handlers
addListener: Runs a function each time an Animated.Value changes.; Collisions and score
AI: Tools like ChatGPT or Claude. Use them to explain and check, not to do your thinking.; Using AI as a study partner
align-items: Lines items up along the cross axis.; Layout with flexbox
alignItems: Lines children up across the main direction.; Styling and flexbox on mobile
alt: Text describing an image, read aloud to people who can't see it.; Common HTML elements
android.package: Your app's unique id on Android, like com.rafi.dailyhabits. Can't change after publishing.; Icons, names and screenshots
Animated: React Native's built-in animation library.; Simple animation
Animated.sequence: Runs animations one after another, like up then down.; Simple animation
Animated.spring: Animates a value with a bouncy, natural feel.; Simple animation
Animated.timing: Animates a value to a target over a set time.; Simple animation
Animated.Value: A number that can animate smoothly, used for positions or opacity.; Simple animation
API: A way for programs to talk to each other. A web API sends data when you request a URL.; Fetching real data
APK: An Android app file you can install directly on a phone. Good for testing.; Building a release with EAS
app config: Settings for your app (app.json or app.config.js) that Expo uses to build it.; Icons, names and screenshots
app.json: The file with your app's name, icon, version and Android package. Also called app config.; Icons, names and screenshots
argument: The actual value you pass when you call a function.; Functions in, values out
array: A list of values in order, like ["Rafi", "Nusrat"].; Loops Arrays Arrays and mapDestructuring and spread
Array<string>: Another way to write string[]: an array of strings.; Reading type annotations
arrow function: A function written with =>.; Functions in, values out Arrow functions
as any: Switches type checking off for a value. Hides problems; avoid it.; Reading type errors
aspect ratio: Width compared with height, like 9:16 for a phone screenshot.; Icons, names and screenshots
async: Marks a function that can use await. It always returns a promise.; Promises and await
asynchronous: Work that finishes later, like loading data, while the rest of the program keeps running.; Promises and await
AsyncStorage: Saves small text values on the phone, so they're still there after the app closes.; Saving data on the phone Sound and saving the best score
attribute: Extra information inside an opening tag, like href="..." or alt="...".; Reading HTML structure
await: Pauses an async function until a promise finishes, then gives its value.; Promises and await
block: Code between { and }. let and const live only inside their block.; Scope
body: The part of a page that is shown on screen.; Reading HTML structure
boolean: true or false.; Values and variables Making decisions with if Reading type annotations
border: The line around the padding.; CSS boxes and spacing
border-box: The box-sizing setting where width includes padding and border. Easier to reason about.; CSS boxes and spacing
bounding box: The rectangle around an object, used to check collisions.; Collisions and score
box model: Every element is a box: content, then padding, border and margin around it.; CSS boxes and spacing
box-sizing: Decides whether width includes padding and border.; CSS boxes and spacing
branch: A separate line of work in Git, so you can change things without breaking main.; Build with reviews
build profile: A named set of build settings, like preview (APK for testing) or production.; Building a release with EAS
button: A clickable control, written with <button>.; Common HTML elements
call: Run a function, like add(2, 3).; Functions in, values out
callback: A function you pass to another function, like the one you give map.; Arrays and mapfilter and findreduceArrow functions Events and handlers
camelCase: Writing words joined with capitals: backgroundColor, not background-color.; Styling and flexbox on mobile
cd: Change directory: moves you into another folder.; The terminal, step by step
child component: A component rendered inside another one. It receives props from its parent.; Props
class: A name you give elements so CSS can style them together, like class="card".; CSS selectors and colours
className: How you write the HTML class attribute in JSX.; Components and JSX
cleanup: A function returned from an effect that undoes it, like stopping a timer.; useEffectThe game loop
clearInterval: Stops a setInterval. Do it in the useEffect cleanup.; The game loop
click: The event when the user clicks or taps.; Events and handlers
closed testing: A test release for invited testers. New personal accounts need it before production.; Play Console and internal testing
closing tag: The tag that ends an element, with a slash, like </p>.; Reading HTML structure
code review: Someone reading your changes and leaving comments before they're merged.; Build with reviews
collision: Two things in a game touching or overlapping.; Collisions and score
colour: In CSS it's spelled color. Set with names, hex like #C6F432, or rgb().; CSS selectors and colours
command: An instruction you type in the terminal, like ls or cd.; The terminal, step by step
commit: A saved snapshot of your project, with a short message saying what changed.; Git and GitHub basics
component: A function that returns what part of the screen should look like.; Components and JSX
condition: An expression that is true or false, like marks >= 40.; Making decisions with if
conditional rendering: Showing different things depending on a condition.; Showing things conditionally
Console: The DevTools tab where errors and console.log messages appear.; Browser DevTools
console: Where console.log prints and errors appear.; Reading error messages
const: Makes a variable you won't point to a new value. Use it by default.; Values and variables
container: The parent element with display flex. It controls where its items go.; Layout with flexbox
content: The inside of the box: the text or image.; CSS boxes and spacing
content rating: An age rating from a short questionnaire in Play Console.; Play Console and internal testing
controlled input: An input whose value comes from state and updates through onChange.; Forms and inputs
copy: A separate object with the same values, so changing one doesn't change the other.; Objects Destructuring and spread
CPU: The chip that runs instructions, one tiny step at a time, very fast.; What a computer actually does
cross axis: The other direction, at right angles to the main axis.; Layout with flexbox
CSS: The language that styles a page: colours, sizes, spacing, layout.; CSS selectors and colours
data: FlatList prop: the array of items to show.; Lists with FlatList
data model: What data your app stores and how it's shaped, like a Habit with name and days.; Plan your app
Data safety: The Play form where you say what data your app collects and why.; Play Console and internal testing
demo video: A short recording showing your app working.; Launch and share
dependency array: The [ ] at the end of useEffect. The effect runs again only when these values change.; useEffect
deploy: Put your site or app online.; Put your page online
destructuring: Unpacking values into separate variables: const { name } = user or const [first] = list.; Destructuring and spread Props
developer account: Your Google Play publisher account. Costs US$25 once.; Play Console and internal testing
DevTools: Tools built into the browser for looking inside a page. Open with F12.; Browser DevTools
diff: The lines that changed: added in green, removed in red.; Build with reviews
directory: Another word for folder.; Files, folders and paths
display flex: Turns an element into a flex container.; Layout with flexbox
DNS: The internet's contact list: turns a domain name into a server's number (IP address).; What happens when you open a URL
documentation: The official explanation of how a tool works. Often called docs.; Using AI as a study partner
domain: The name part of a URL, like mamunlabs.com.; What happens when you open a URL
e.preventDefault(): Stops the browser's default action, like reloading the page on form submit.; Forms and inputs
e.target.value: The current text of the input that fired the event.; Forms and inputs
EAS: Expo Application Services: Expo's cloud tools for building and submitting apps.; Building a release with EAS
EAS Build: Builds your app in Expo's cloud, so you don't need Android Studio.; Building a release with EAS
eas.json: The file with your build profiles.; Building a release with EAS
editor: A program for writing and editing code.; Set up VS Code and Node
effect: Code that runs after a render to sync with something outside React.; useEffect
element: A piece of a page: an opening tag, its content and the closing tag.; Reading HTML structure
Elements panel: The DevTools tab that shows the page's HTML.; Browser DevTools
else: Runs when the if condition is false.; Making decisions with if
else if: Checks another condition when the one before was false.; Making decisions with if
endpoint: One URL of an API that gives one kind of data.; Calling an API
error: A problem that stops code from working. The message says what went wrong.; Browser DevTools Reading error messages
error message: The text a program shows when something goes wrong. It usually says what and where.; Using AI as a study partner
error state: What you show when something failed, like No internet. Try again.; Loading and error states Fetching data in React
event: Something that happens on a page or app, like a click or a key press.; Events and handlers
event handler: The function that runs when an event happens.; Events and handlers Events in React Touch input
event object: Information about the event, passed to the handler, like which key was pressed.; Events and handlers
expected: What you thought would happen.; Using AI as a study partner
Expo: A toolkit that runs React Native apps on your phone without extra setup.; Your first Expo app
Expo Router: Expo's navigation: each file in the app folder becomes a screen.; Screens and navigation
expo-audio: Expo's library for playing sounds.; Sound and saving the best score
export: Marks code that other files may import.; Modules and npm
export default: Marks the main thing a file shares, like the App component.; Modules and npm Components and JSX Your first Expo app
extension: The ending of a file name, like .js or .html, that says what kind of file it is.; Files, folders and paths Set up VS Code and Node
feature graphic: A 1024×500 banner for your Play listing.; Your store listing and release
feedback: What others tell you about your work, to make it better.; Build with reviews Launch and share
fetch: The built-in function that requests a URL and returns a promise of the response.; Fetching real data Fetching data in React
file: A named piece of saved data, like a photo, a document or a code file.; Files, folders and paths
filter: Makes a new array with only the items where the callback returns true.; filter and find
finally: A block after try/catch that runs either way, success or error.; Loading and error states
find: Gives the first item where the callback returns true, or undefined.; filter and find
FlatList: A fast scrolling list that only draws the rows you can see.; Lists with FlatList
flex-direction: Row (side by side) or column (top to bottom). This sets the main axis.; Layout with flexbox
flex: 1: Makes a view grow to fill the space it's given. Often on the screen's outer View.; Styling and flexbox on mobile
flexbox: A CSS layout that lines items up in a row or a column. React Native uses it too.; Layout with flexbox
flexDirection: column (default in React Native, top to bottom) or row (side by side).; Styling and flexbox on mobile
folder: A container for files and other folders. Also called a directory.; Files, folders and paths
font: The style of the letters. Set with font-family and font-size.; CSS selectors and colours
for: A loop with a counter: start, condition, step.; Loops
for...of: Loops over each item in an array, one at a time.; Loops
form: A group of inputs the user fills in and submits.; Common HTML elements
full description: Up to 4000 characters explaining your app on Play.; Your store listing and release
function: A named, reusable block of code. Values go in, a value comes out.; Functions in, values out
functional update: setGame((g) => ...) uses the latest state, safe inside loops and timers.; Collisions and score
game loop: Code that runs many times a second: move things, check collisions, draw.; The game loop
game over: The state when the player loses. The loop stops until a restart.; Collisions and score
gap: Space between flex items.; Layout with flexbox
getItem: Reads a saved value. Gives null if nothing was saved yet. Returns a promise.; Saving data on the phone Sound and saving the best score
Git: A tool that saves snapshots of your project so you can see and undo changes.; Git and GitHub basics
git add: Stages changes for the next commit.; Git and GitHub basics
git commit: Saves the staged changes as a snapshot.; Git and GitHub basics
git log: Lists past commits, newest first.; Git and GitHub basics
git status: Shows what has changed and what is staged.; Git and GitHub basics
GitHub: A website that stores Git projects online so you can share and back them up.; Git and GitHub basics
GitHub Pages: Free hosting for static sites, straight from a GitHub repository.; Put your page online
global: A variable declared outside every block and function. Visible everywhere.; Scope
hallucination: When an AI states something wrong with confidence.; Using AI as a study partner
head: The part of a page with information about it (title, styles). Not shown in the page.; Reading HTML structure
heading: A title element, from <h1> (biggest) to <h6>.; Common HTML elements
home folder: Your own folder on the computer, where your documents and projects live.; Files, folders and paths
hosting: Keeping your site on a server so anyone can open it.; Put your page online
HTML: The language that describes the structure of a web page: headings, text, links.; Reading HTML structure
https: The secure web protocol. Phones and Play require https for most requests.; Calling an API
i++: Adds 1 to i. Common as the step in a for loop.; Loops
icon: The picture people tap to open your app. Make it 1024×1024.; Icons, names and screenshots
id: A unique identifier for an item, often used as its key.; Lists and keys
if: Runs a block of code only when a condition is true.; Making decisions with if
image: A picture on the page, written with <img src="..." alt="...">.; Common HTML elements
Image: Shows a picture in React Native. Needs a source and a width and height.; View, Text and Image
implicit return: An arrow function without { } gives back its expression without writing return.; Arrow functions
import: Brings in code that another file or package exports.; Modules and npm
includes: Checks whether an array (or string) has a value. Gives true or false.; Arrays
index: The position of an item in an array, counting from 0.; Arrays
index.html: The default page a server shows for a folder.; Put your page online
indexOf: Gives the position of a value, or -1 if it isn't there.; Arrays
input: Information going into a computer or program, like a key press or a number you type.; What a computer actually does Common HTML elements
inspect: Right-click an element and look at its HTML and CSS in DevTools.; Browser DevTools
instruction: One small step in a program, like "add these two numbers".; What a computer actually does
integrated terminal: The terminal built into VS Code.; Set up VS Code and Node
interface: Another way to name an object type: interface Student { name: string }.; Types for objects
internal testing: A quick test release for up to a small group you invite.; Play Console and internal testing
Ionicons: A free icon set you can use in Expo apps.; Tabs
IP address: The number that identifies a computer on the internet.; What happens when you open a URL
is not defined: Part of a ReferenceError: this name doesn't exist here.; Scope
item: Flexbox: a child inside the flex container. Arrays: one value in the list.; Layout with flexbox Arrays
iteration: One pass through a loop.; Loops
JSON: A text format for data that looks like JavaScript objects and arrays.; Fetching real data
JSON.parse: Turns JSON text back into a value.; Saving data on the phone
JSON.stringify: Turns a value into JSON text, so you can save it.; Saving data on the phone
JSX: HTML-like code inside JavaScript that React turns into the screen.; Components and JSX
justify-content: Spaces items along the main axis.; Layout with flexbox
justifyContent: Spaces children along the main direction (down for column, across for row).; Styling and flexbox on mobile
key: The name of a value inside an object.; Objects
key prop: A unique id on each item in a list, so React can tell the items apart.; Lists and keys
KeyboardAvoidingView: Moves content up so the keyboard doesn't cover the input.; Safe areas and the keyboard
keyExtractor: FlatList prop: a function that gives each item a unique key, like item.id.; Lists with FlatList
keystore: The secret key that signs your app. Lose it and you can't update the app. EAS can keep it for you.; Building a release with EAS
label: The text that says what an input is for.; Common HTML elements
length: How many characters a string has, or how many items an array has.; Strings and numbers Arrays
let: Makes a variable whose value can change.; Values and variables
line number: Where the error happened, like script.js:12.; Reading error messages
link: Text you click to go somewhere, written with <a href="...">.; Common HTML elements
Link: A tappable component that opens another screen.; Screens and navigation
list: Items in a row, written with <ul> (bullets) or <ol> (numbers) and <li> for each item.; Common HTML elements
literal type: A type that allows only exact values, like "paid" | "due".; Unions and optional values
loading state: The time between asking for data and getting it. Show a message like Loading…; Loading and error states Fetching data in React
local: A variable declared inside a block or function. Visible only there.; Scope
loop: Code that repeats.; Loops
ls: Lists the files and folders where you are. On Windows PowerShell, dir also works.; The terminal, step by step
LTS: Long-term support: the stable version of a tool to install.; Set up VS Code and Node
main axis: The direction items flow in: across for row, down for column.; Layout with flexbox
map: Makes a new array by running a function on every item.; Arrays and mapLists and keys
margin: Space outside the box, between it and other boxes.; CSS boxes and spacing
Markdown: Simple text formatting used in READMEs: # for headings, - for lists.; Launch and share
merge: Bring a branch's changes into main.; Build with reviews
mkdir: Make directory: creates a new folder.; The terminal, step by step
module: A JavaScript file that shares some of its code with other files using export and import.; Modules and npm
MVP: Minimum viable product: the smallest version of your app that is actually useful.; Plan your app
narrowing: Checking a value (like if (phone)) so TypeScript knows its exact type inside the block.; Unions and optional values
nesting: Putting elements inside other elements. Indentation shows the nesting.; Reading HTML structure View, Text and Image
Network tab: The DevTools tab listing every file the page loaded, with status codes.; Browser DevTools
new array: map and filter give back a new array; the original stays the same.; Arrays and map
node --version: Prints which version of Node.js is installed. A quick check that it works.; Set up VS Code and Node
node_modules: The folder where npm puts installed packages. Never edit it, and don't commit it.; Modules and npm
Node.js: Lets you run JavaScript on your computer, outside the browser.; Set up VS Code and Node
not assignable: Part of an error: the value's type doesn't fit where you put it.; Reading type errors
notch: The camera cut-out at the top of many phones.; Safe areas and the keyboard
npm: Node's package manager: installs code other people wrote, listed in package.json.; Modules and npm
null: "Nothing" on purpose. A component that returns null shows nothing.; Showing things conditionally Sound and saving the best score
number: A numeric value, like 500 or 3.5.; Values and variables Strings and numbers Reading type annotations
Number(): Turns text like "20" into the number 20.; Strings and numbers
number[]: An array of numbers.; Reading type annotations
object: A group of values under names (keys): { name: "Rafi", year: 2 }.; Objects Destructuring and spread
object type: Describes the shape of an object: which properties it has and their types.; Types for objects
off-by-one: A bug where a loop runs one time too many or too few.; Loops
onChange: The prop that runs a function every time the input's value changes.; Forms and inputs
onChangeText: Runs on every letter typed in a TextInput, with the new text.; Pressable and TextInput
onClick: The prop that sets what runs when an element is clicked.; Events in React
onClick={handleClick}: Pass the function itself. onClick={handleClick()} would run it immediately.; Events in React
onPress: The prop that runs a function when the user taps.; Pressable and TextInputTouch input
onPressIn: Runs the moment a finger touches, before it lifts. Good for games.; Touch input
onSubmit: The prop that runs when a form is submitted.; Forms and inputs
open testing: A test release anyone can join from the Play Store.; Play Console and internal testing
opening tag: The tag that starts an element, like <p>.; Reading HTML structure
optional property: A property that may be missing, marked with ?: phone?: string.; Unions and optional values
output: What comes out after processing, like text on screen or a saved file.; What a computer actually does
overlap: Two rectangles sharing some space. That's a collision.; Collisions and score
package: Reusable code published on npm, like react.; Modules and npm
package.json: The file listing your project's name, scripts and the packages it needs.; Modules and npm
padding: Space inside the box, between the content and the border.; CSS boxes and spacing
paragraph: A block of text, written with <p>.; Common HTML elements
parameter: The name a function uses for a value it receives.; Functions in, values out Arrow functions
parent component: A component that renders another component inside it.; Props
path: The address of a file or folder, like documents/notes/todo.txt.; Files, folders and paths What happens when you open a URL
pending: A promise that hasn't finished yet.; Promises and await
placeholder: Grey hint text inside an empty input, like Add a habit.; Pressable and TextInput
Platform.OS: "ios" or "android", so code can do something different on each.; Safe areas and the keyboard
Play Console: Google's website for publishing and managing your apps.; Play Console and internal testing
Play Store link: The web address of your app's Play page, to share with people.; Launch and share
possibly undefined: TypeScript warning that a value might be missing, so you must check it first.; Unions and optional values
Pressable: A React Native wrapper that makes anything tappable.; Pressable and TextInputTouch input
privacy policy: A page explaining what data your app uses. Play requires a link to one.; Your store listing and release
processing: The work the computer does on the input, step by step.; What a computer actually does
production: The real release everyone can find on Google Play.; Play Console and internal testing
program: A list of exact instructions for the computer to follow.; What a computer actually does
promise: An object for a value that will arrive later, or an error if it fails.; Promises and await
prompt: The message you type to an AI tool.; Using AI as a study partner
property: CSS: what you change, like color. Objects: a key and its value inside an object.; CSS selectors and colours Objects Types for objects
props: Values a parent component passes to a child, like attributes on a tag.; Props
pull request: A request on GitHub to merge a branch, where others can review the changes.; Build with reviews
push: Git: send your commits to GitHub. Arrays: add an item to the end of a list.; Git and GitHub basics Arrays
pwd: Print working directory: shows which folder you are in.; The terminal, step by step
RAM: Fast, short-term memory. It holds what's running now and is cleared when the power goes off.; What a computer actually does
re-render: React runs the component again after state changes.; State with useState
README: The first file people read in a repository: what it is and how to run it.; Launch and share
Reanimated: A more powerful animation library used by bigger apps and games.; Simple animation
red underline: How your editor shows a TypeScript error. Hover over it to read the message.; Why types catch bugs
reduce: Combines all items of an array into one value, like a total.; reduce
reference: A pointer to an object. Two names can point to the same object.; Objects
ReferenceError: The error when you use a name that doesn't exist, often a typo.; Scope Reading error messages
relative path: A path that starts from where you are now, like ../images/logo.png.; Files, folders and paths Put your page online
release: A version of your app sent to a testing or production track.; Your store listing and release
release notes: A short list of what's new in this version.; Your store listing and release
remote: The copy of your repository on GitHub.; Git and GitHub basics
render: React runs your component to work out what the screen should show.; Components and JSX State with useState
renderItem: FlatList prop: a function that returns the row for one item.; Lists with FlatList
repository: A project folder tracked by Git, often shortened to repo.; Git and GitHub basics Put your page online
request: What your browser sends to a server: "please give me this page".; What happens when you open a URL Fetching real data
response: What the server sends back: the page, plus a status code.; What happens when you open a URL Fetching real data
response.json(): Reads a fetch response's body and turns the JSON into a JavaScript value. Returns a promise.; Fetching real data
response.ok: true when the server answered with a success status (200–299).; Loading and error states
return: Sends a value back out of a function. Without it, you get undefined.; Functions in, values out Arrays and mapArrow functions
return type: The type a function gives back, written after the brackets: (): number.; Reading type annotations
review comment: A note on a specific line in a pull request.; Build with reviews
route: A screen and its address, like /habit/3.; Screens and navigation
router.back: Goes back to the previous screen.; Screens and navigation
router.push: Opens a screen from code, like after saving a form.; Screens and navigation
rule: A CSS block: a selector plus the styles inside { }.; CSS selectors and colours
safe area: The part of the screen not covered by the notch, status bar or home bar.; Safe areas and the keyboard
SafeAreaView: A view that keeps content inside the safe area. Use the one from react-native-safe-area-context.; Safe areas and the keyboard
scope: Code: where a variable can be seen and used. Planning: what your app will and will not do.; Scope Plan your app
screen list: Every screen your app needs, written down before you build.; Plan your app
screen recording: A video of your phone's screen, built into Android.; Launch and share
screenshot: A picture of your app's screen, used in the Play Store listing.; Icons, names and screenshots
ScrollView: A scrolling box that draws everything inside it at once. Fine for short content.; Lists with FlatList
selector: The part of a CSS rule that says which elements it styles, like p or .card.; CSS selectors and colours
semantic: Using the tag that matches the meaning, like <nav> for navigation, not a plain <div>.; Common HTML elements
server: A computer that sends web pages and data when asked.; What happens when you open a URL
setInterval: Runs a function again and again, every few milliseconds.; The game loop
setItem: Saves a value under a key. Returns a promise.; Saving data on the phone Sound and saving the best score
setter: The function that changes state, like setCount. It triggers a new render.; State with useState
setTimeout: Runs a function once, after a delay in milliseconds.; Promises and await
shadowing: A new variable with the same name inside a block, hiding the outer one.; Scope
short description: Up to 80 characters under your app's name on Play.; Your store listing and release
slug: A short, URL-friendly name for your project, like daily-habits.; Icons, names and screenshots
sound effect: A short non-musical sound, like a click, for a game event.; Sound and saving the best score
source: Where an Image comes from: a file with require("./cat.png") or a web link with { uri }.; View, Text and Image
specificity: How CSS decides which rule wins when two rules style the same thing.; CSS selectors and colours
splash screen: What shows for a moment while the app opens.; Icons, names and screenshots
spread: ... copies the items of an array or the properties of an object into a new one.; Destructuring and spread
stack: The list of lines under an error showing where it happened. Read the top line first.; Reading error messages
Stack: Navigation where new screens slide on top and Back returns to the previous one.; Screens and navigation
stage: Choose which changes go into the next commit (git add).; Git and GitHub basics
starting value: What the accumulator starts as, the last argument to reduce.; reduce
state: Data a component remembers between renders.; State with useState
status code: A number in every response that says how it went. 200 is OK, 404 is not found.; What happens when you open a URL Browser DevTools
storage: Long-term memory (SSD or hard disk). Files stay there after you switch off.; What a computer actually does
store listing: Your app's page on Google Play: name, descriptions, icon and screenshots.; Your store listing and release
string: Text, written in quotes: "Nusrat".; Values and variables Strings and numbers Reading type annotations
Student[]: An array of Student objects.; Types for objects
Styles: The DevTools pane that shows, and lets you change, the CSS of the selected element.; Browser DevTools
stylesheet: A .css file with your styles, linked from the HTML.; CSS selectors and colours
StyleSheet: React Native's way to write styles as JavaScript objects.; Your first Expo app
StyleSheet.create: Groups your React Native styles into one object with names.; Styling and flexbox on mobile
SyntaxError: The error when the code isn't valid JavaScript, like a missing bracket.; Reading error messages
tabBarIcon: Tabs.Screen option that draws the tab's icon.; Tabs
Tabs: Navigation with a bar of tabs at the bottom.; Tabs
Tabs.Screen: Sets the title and icon for one tab.; Tabs
tag: An HTML marker in angle brackets, like <p> or </p>.; Reading HTML structure
target API level: The Android version your app is built for. Google requires a recent one.; Play Console and internal testing
template literal: A string in backticks that can include values with ${...}.; Strings and numbers
terminal: A window where you type commands instead of clicking.; The terminal, step by step
ternary: condition ? a : b gives a when the condition is true, b when false.; Showing things conditionally
tester: Someone who installs your test release and gives feedback.; Play Console and internal testing
Text: Shows words in React Native. All text must be inside it.; Your first Expo app
TextInput: A box the user can type into on the phone.; Pressable and TextInput
throw: Creates an error on purpose, which stops the code until a catch handles it.; Loading and error states
tick: One run of the game loop.; The game loop
toFixed: Rounds a number to a set number of decimals for display, like (12.5).toFixed(2).; Strings and numbers
total: A running sum, the usual job for reduce.; reduce
touch: Creates a new, empty file.; The terminal, step by step Touch input
toUpperCase: Gives back a copy of a string in capital letters.; Strings and numbers
true / false: The two boolean values. filter and find use them to decide what to keep.; filter and find
try...catch: Runs code in try; if it throws an error, the catch block runs instead of crashing.; Loading and error states
TS2322: The error code for "Type X is not assignable to type Y".; Reading type errors
type: What kind of value something is, like string, number or a Student object.; Why types catch bugs
type alias: A name for a type: type Student = { name: string }.; Types for objects
type annotation: Writing the type after a name, like let age: number.; Why types catch bugs Reading type annotations
type checker: The part of TypeScript that compares your code against the types and reports mistakes.; Why types catch bugs
type error: A mistake TypeScript finds, like passing a string where a number is expected.; Reading type errors
type inference: TypeScript working out a type by itself from the value, so you don't have to write it.; Reading type annotations
TypeError: The error when you use a value the wrong way, like reading a property of undefined.; Reading error messages
typeof: Tells you the type of a value, like "number" or "string".; Values and variables
TypeScript: JavaScript plus types. It checks your code for mistakes before it runs.; Why types catch bugs
undefined: JavaScript's "no value here". Often a sign something is missing.; Functions in, values out filter and findReading error messages
union type: A value that can be one of several types: string | number.; Unions and optional values
uri: A web address for an image or file, used as source={{ uri: "https://..." }}.; View, Text and Image
URL: A web address, like https://learn.mamunlabs.com/journey.; What happens when you open a URL
useAudioPlayer: The expo-audio hook that loads a sound you can play.; Sound and saving the best score
useEffect: Runs code after React renders, for things outside React like fetching data.; useEffectFetching data in React
useLocalSearchParams: Reads values from the route, like the id in /habit/3.; Screens and navigation
user story: "As a student, I want to…, so that…": one need, from the user's side.; Plan your app
useRef: Keeps a value between renders without causing a re-render.; Simple animation
username.github.io: The address of your GitHub Pages site.; Put your page online
useState: The React function that gives a component a piece of state and a setter.; State with useState
value: A piece of data, like 500 or "Nusrat". In CSS, the setting you choose, like red.; CSS selectors and colours Values and variables Objects
variable: A name that holds a value, like balance.; Values and variables
version: The version people see, like 1.0.1.; Building a release with EAS
versionCode: A whole number that must go up with every Play upload.; Building a release with EAS
View: A box in React Native, like a div on the web.; Your first Expo app
Vite: A fast tool that creates and runs React projects: npm create vite@latest.; Components and JSX
VS Code: A free code editor from Microsoft, the one used in this course.; Set up VS Code and Node
while: Repeats as long as a condition is true.; Loops
width: How wide the box is. What it includes depends on box-sizing.; CSS boxes and spacing
wireframe: A rough sketch of a screen, boxes and labels only.; Plan your app
working directory: The folder the terminal is in right now.; The terminal, step by step