API Endpoints

The authentication system provides the following API endpoints:

Base URL

https://auth-materioa.netlify.app is the actual auth API base URL.

Authentication

Most endpoints require authentication via a JWT token. After logging in, you’ll receive a token that should be passed in the Authorization header in the format: Bearer YOUR_TOKEN.

Examples

1. User Signup

curl -X POST https://auth-materioa.netlify.app/.netlify/functions/signup \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "username": "username123",
    "displayName": "User Name",
    "password": "secure-password"
  }'

Response:

{
  "message": "User created successfully",
  "user": {
    "id": "user-uuid",
    "username": "username123",
    "displayName": "User Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T12:34:56.789Z"
  },
  "token": "your.jwt.token",
  "recoveryKey": "abcdef-123456-ghijkl"
}

2. User Login

curl -X POST https://auth-materioa.netlify.app/.netlify/functions/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "user@example.com",
    "password": "secure-password"
  }'

Note: The username field accepts either an email address or a username. The system automatically detects if it’s an email format and searches the appropriate field in the database.

Response:

{
  "token": "your.jwt.token",
  "user": {
    "id": "user-uuid",
    "username": "username123",
    "displayName": "User Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T12:34:56.789Z"
  }
}

3. Get User Profile

curl -X GET https://auth-materioa.netlify.app/.netlify/functions/profile \
  -H "Authorization: Bearer your.jwt.token"

Response:

{
  "user": {
    "id": "user-uuid",
    "username": "username123",
    "displayName": "User Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T12:34:56.789Z"
  }
}

4. Update User Profile

curl -X PUT https://auth-materioa.netlify.app/.netlify/functions/profile \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your.jwt.token" \
  -d '{
    "username": "updated_username",
    "displayName": "Updated Name"
  }'

Response:

{
  "message": "Profile updated successfully",
  "user": {
    "id": "user-uuid",
    "username": "updated_username",
    "displayName": "Updated Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T14:00:00.000Z"
  }
}

5. Change Password

curl -X PUT https://auth-materioa.netlify.app/.netlify/functions/profile \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your.jwt.token" \
  -d '{
    "currentPassword": "secure-password",
    "newPassword": "new-secure-password"
  }'

Response:

{
  "message": "Profile updated successfully",
  "user": {
    "id": "user-uuid",
    "username": "username123",
    "displayName": "User Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T15:00:00.000Z"
  }
}

6. Generate New Recovery Key

curl -X PUT https://auth-materioa.netlify.app/.netlify/functions/profile \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your.jwt.token" \
  -d '{
    "currentPassword": "secure-password",
    "generateNewRecoveryKey": true
  }'

Response:

{
  "message": "Profile updated successfully",
  "user": {
    "id": "user-uuid",
    "username": "username123",
    "displayName": "User Name",
    "email": "user@example.com",
    "profilePicture": null,
    "createdAt": "2025-05-13T12:34:56.789Z",
    "updatedAt": "2025-05-13T16:00:00.000Z"
  },
  "recoveryKey": "new-recovery-key-123456"
}

7. Reset Password with Recovery Key

curl -X PUT https://auth-materioa.netlify.app/.netlify/functions/forgot-password \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "recoveryKey": "abcdef-123456-ghijkl",
    "newPassword": "new-secure-password"
  }'

Response:

{
  "message": "Password reset successfully"
}

8. Request Password Reset (Get Recovery Key)

curl -X POST https://auth-materioa.netlify.app/.netlify/functions/forgot-password \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com"
  }'

Response:

{
  "message": "If this email exists in our system, a recovery key has been sent."
}

9. Delete Account

curl -X DELETE https://auth-materioa.netlify.app/.netlify/functions/profile \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your.jwt.token" \
  -d '{
    "password": "secure-password"
  }'

Response:

{
  "message": "Account deleted successfully"
}

Bash Script Examples

User Registration and Login

#!/bin/bash

# Configuration
API_URL="https://auth-materioa.netlify.app/.netlify/functions"
EMAIL="user@example.com"
PASSWORD="secure-password"
USERNAME="username123"
DISPLAY_NAME="User Name"

# Function to handle API errors
handle_error() {
  if [ $? -ne 0 ]; then
    echo "Error: API call failed"
    exit 1
  fi
  
  if echo "$1" | grep -q "error"; then
    echo "API Error: $(echo "$1" | jq -r '.error // .message')"
    exit 1
  fi
}

# Sign up a new user
echo "Creating new user..."
SIGNUP_RESPONSE=$(curl -s -X POST "$API_URL/signup" \
  -H "Content-Type: application/json" \
  -d "{
    \"email\": \"$EMAIL\",
    \"username\": \"$USERNAME\",
    \"displayName\": \"$DISPLAY_NAME\",
    \"password\": \"$PASSWORD\"
  }")

handle_error "$SIGNUP_RESPONSE"

# Extract token and recovery key
TOKEN=$(echo "$SIGNUP_RESPONSE" | jq -r '.token')
RECOVERY_KEY=$(echo "$SIGNUP_RESPONSE" | jq -r '.recoveryKey')

echo "User created successfully!"
echo "Recovery Key: $RECOVERY_KEY"
echo "JWT Token: $TOKEN"

# Save token to file for later use
echo "$TOKEN" > auth_token.txt

# Get user profile
echo -e "\nFetching user profile..."
PROFILE_RESPONSE=$(curl -s -X GET "$API_URL/profile" \
  -H "Authorization: Bearer $TOKEN")

handle_error "$PROFILE_RESPONSE"

echo "User Profile:"
echo "$PROFILE_RESPONSE" | jq

echo -e "\nAuthentication completed successfully!"

Full User Management Script

#!/bin/bash

# Configuration
API_URL="https://auth-materioa.netlify.app/.netlify/functions"
TOKEN_FILE="auth_token.txt"

# Command line arguments
ACTION=$1
shift

# Help message
show_help() {
  echo "Usage: ./materio-auth.sh [ACTION] [OPTIONS]"
  echo ""
  echo "Actions:"
  echo "  signup EMAIL USERNAME DISPLAYNAME PASSWORD  - Create a new user"
  echo "  login EMAIL PASSWORD                      - Login existing user"
  echo "  profile                                   - Get current user profile"
  echo "  update-profile USERNAME DISPLAYNAME       - Update user profile"
  echo "  change-password CURRENT_PWD NEW_PWD       - Change user password"
  echo "  gen-recovery                              - Generate new recovery key"
  echo "  reset-password EMAIL RECOVERY_KEY NEW_PWD - Reset password with recovery key"
  echo "  delete-account PASSWORD                   - Delete current user account"
  echo "  help                                      - Show this help message"
}

# Function to handle API errors
handle_error() {
  if [ $? -ne 0 ]; then
    echo "Error: API call failed"
    return 1
  fi
  
  if echo "$1" | grep -q "error"; then
    echo "API Error: $(echo "$1" | jq -r '.error // .message')"
    return 1
  fi
  
  return 0
}

# Get saved token
get_token() {
  if [ ! -f "$TOKEN_FILE" ]; then
    echo "Error: Not logged in. Please login first."
    exit 1
  fi
  
  TOKEN=$(cat "$TOKEN_FILE")
  if [ -z "$TOKEN" ]; then
    echo "Error: Invalid token. Please login again."
    exit 1
  fi
  
  echo "$TOKEN"
}

# Sign up a new user
signup() {
  local email=$1
  local username=$2
  local displayName=$3
  local password=$4
  
  if [ -z "$email" ] || [ -z "$username" ] || [ -z "$displayName" ] || [ -z "$password" ]; then
    echo "Error: Missing required parameters"
    show_help
    exit 1
  fi
  
  echo "Creating new user..."
  SIGNUP_RESPONSE=$(curl -s -X POST "$API_URL/signup" \
    -H "Content-Type: application/json" \
    -d "{
      \"email\": \"$email\",
      \"username\": \"$username\",
      \"displayName\": \"$displayName\",
      \"password\": \"$password\"
    }")
  
  if handle_error "$SIGNUP_RESPONSE"; then
    TOKEN=$(echo "$SIGNUP_RESPONSE" | jq -r '.token')
    RECOVERY_KEY=$(echo "$SIGNUP_RESPONSE" | jq -r '.recoveryKey')
    
    echo "$TOKEN" > "$TOKEN_FILE"
    
    echo "User created successfully!"
    echo "Recovery Key: $RECOVERY_KEY"
    echo "JWT Token saved to $TOKEN_FILE"
  fi
}

# Login user
login() {
  local email=$1
  local password=$2
  
  if [ -z "$email" ] || [ -z "$password" ]; then
    echo "Error: Missing required parameters"
    show_help
    exit 1
  fi
  
  echo "Logging in..."
  LOGIN_RESPONSE=$(curl -s -X POST "$API_URL/login" \
    -H "Content-Type: application/json" \
    -d "{
      \"email\": \"$email\",
      \"password\": \"$password\"
    }")
  
  if handle_error "$LOGIN_RESPONSE"; then
    TOKEN=$(echo "$LOGIN_RESPONSE" | jq -r '.token')
    echo "$TOKEN" > "$TOKEN_FILE"
    echo "Login successful!"
    echo "JWT Token saved to $TOKEN_FILE"
  fi
}

# Get user profile
get_profile() {
  TOKEN=$(get_token)
  
  echo "Fetching user profile..."
  PROFILE_RESPONSE=$(curl -s -X GET "$API_URL/profile" \
    -H "Authorization: Bearer $TOKEN")
  
  if handle_error "$PROFILE_RESPONSE"; then
    echo "User Profile:"
    echo "$PROFILE_RESPONSE" | jq
  fi
}

# Update user profile
update_profile() {
  local username=$1
  local displayName=$2
  
  if [ -z "$username" ] || [ -z "$displayName" ]; then
    echo "Error: Missing required parameters"
    show_help
    exit 1
  fi
  
  TOKEN=$(get_token)
  
  echo "Updating profile..."
  UPDATE_RESPONSE=$(curl -s -X PUT "$API_URL/profile" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"username\": \"$username\",
      \"displayName\": \"$displayName\"
    }")
  
  if handle_error "$UPDATE_RESPONSE"; then
    echo "Profile updated successfully!"
    echo "$UPDATE_RESPONSE" | jq
  fi
}

# Change password
change_password() {
  local currentPassword=$1
  local newPassword=$2
  
  if [ -z "$currentPassword" ] || [ -z "$newPassword" ]; then
    echo "Error: Missing required parameters"
    show_help
    exit 1
  fi
  
  TOKEN=$(get_token)
  
  echo "Changing password..."
  CHANGE_RESPONSE=$(curl -s -X PUT "$API_URL/profile" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"currentPassword\": \"$currentPassword\",
      \"newPassword\": \"$newPassword\"
    }")
  
  if handle_error "$CHANGE_RESPONSE"; then
    echo "Password changed successfully!"
  fi
}

# Generate new recovery key
gen_recovery() {
  local currentPassword=$1
  
  if [ -z "$currentPassword" ]; then
    echo "Error: Current password required"
    show_help
    exit 1
  fi
  
  TOKEN=$(get_token)
  
  echo "Generating new recovery key..."
  RECOVERY_RESPONSE=$(curl -s -X PUT "$API_URL/profile" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"currentPassword\": \"$currentPassword\",
      \"generateNewRecoveryKey\": true
    }")
  
  if handle_error "$RECOVERY_RESPONSE"; then
    NEW_KEY=$(echo "$RECOVERY_RESPONSE" | jq -r '.recoveryKey')
    echo "New recovery key: $NEW_KEY"
  fi
}

# Reset password with recovery key
reset_password() {
  local email=$1
  local recoveryKey=$2
  local newPassword=$3
  
  if [ -z "$email" ] || [ -z "$recoveryKey" ] || [ -z "$newPassword" ]; then
    echo "Error: Missing required parameters"
    show_help
    exit 1
  fi
  
  echo "Resetting password..."
  RESET_RESPONSE=$(curl -s -X PUT "$API_URL/forgot-password" \
    -H "Content-Type: application/json" \
    -d "{
      \"email\": \"$email\",
      \"recoveryKey\": \"$recoveryKey\",
      \"newPassword\": \"$newPassword\"
    }")
  
  if handle_error "$RESET_RESPONSE"; then
    echo "Password reset successfully!"
  fi
}

# Delete account
delete_account() {
  local password=$1
  
  if [ -z "$password" ]; then
    echo "Error: Password required"
    show_help
    exit 1
  fi
  
  TOKEN=$(get_token)
  
  echo "WARNING: You are about to delete your account. This action cannot be undone."
  read -p "Are you sure? (y/n): " CONFIRM
  
  if [ "$CONFIRM" != "y" ]; then
    echo "Account deletion cancelled."
    exit 0
  fi
  
  echo "Deleting account..."
  DELETE_RESPONSE=$(curl -s -X DELETE "$API_URL/profile" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" \
    -d "{
      \"password\": \"$password\"
    }")
  
  if handle_error "$DELETE_RESPONSE"; then
    echo "Account deleted successfully!"
    rm -f "$TOKEN_FILE"
  fi
}

# Main execution logic based on action
case "$ACTION" in
  signup)
    signup "$1" "$2" "$3" "$4"
    ;;
  login)
    login "$1" "$2"
    ;;
  profile)
    get_profile
    ;;
  update-profile)
    update_profile "$1" "$2"
    ;;
  change-password)
    change_password "$1" "$2"
    ;;
  gen-recovery)
    gen_recovery "$1"
    ;;
  reset-password)
    reset_password "$1" "$2" "$3"
    ;;
  delete-account)
    delete_account "$1"
    ;;
  help|--help|-h)
    show_help
    ;;
  *)
    echo "Unknown action: $ACTION"
    show_help
    exit 1
    ;;
esac

Python Script Example

Here’s a simple Python client for the auth API:

#!/usr/bin/env python3
import argparse
import json
import os
import requests
import sys

# Configuration
API_URL = "https://auth-materioa.netlify.app/.netlify/functions"
TOKEN_FILE = "auth_token.txt"

def save_token(token):
    """Save token to file"""
    with open(TOKEN_FILE, 'w') as f:
        f.write(token)
    print(f"Token saved to {TOKEN_FILE}")

def get_token():
    """Get token from file"""
    try:
        with open(TOKEN_FILE, 'r') as f:
            token = f.read().strip()
            if not token:
                raise ValueError("Empty token")
            return token
    except (IOError, ValueError) as e:
        print(f"Error reading token: {e}")
        print("Please login first")
        sys.exit(1)

def handle_response(response):
    """Handle API response and errors"""
    try:
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        try:
            error_data = response.json()
            error_msg = error_data.get('error') or error_data.get('message') or str(e)
            print(f"API Error: {error_msg}")
        except:
            print(f"HTTP Error: {e}")
        sys.exit(1)
    except requests.exceptions.RequestException as e:
        print(f"Request Error: {e}")
        sys.exit(1)
    except json.JSONDecodeError:
        print("Error: Invalid JSON response")
        sys.exit(1)

def signup(args):
    """Create a new user"""
    data = {
        "email": args.email,
        "username": args.username,
        "displayName": args.display_name,
        "password": args.password
    }
    
    print("Creating new user...")
    response = requests.post(f"{API_URL}/signup", json=data)
    result = handle_response(response)
    
    token = result.get('token')
    recovery_key = result.get('recoveryKey')
    
    save_token(token)
    print("User created successfully!")
    print(f"Recovery Key: {recovery_key}")
    return result

def login(args):
    """Login existing user"""
    data = {
        "email": args.email,
        "password": args.password
    }
    
    print("Logging in...")
    response = requests.post(f"{API_URL}/login", json=data)
    result = handle_response(response)
    
    token = result.get('token')
    save_token(token)
    print("Login successful!")
    return result

def get_profile(args):
    """Get user profile"""
    token = get_token()
    headers = {"Authorization": f"Bearer {token}"}
    
    print("Fetching user profile...")
    response = requests.get(f"{API_URL}/profile", headers=headers)
    result = handle_response(response)
    
    print("User Profile:")
    print(json.dumps(result, indent=2))
    return result

def update_profile(args):
    """Update user profile"""
    token = get_token()
    headers = {"Authorization": f"Bearer {token}"}
    
    data = {}
    if args.username:
        data["username"] = args.username
    if args.display_name:
        data["displayName"] = args.display_name
    
    print("Updating profile...")
    response = requests.put(f"{API_URL}/profile", headers=headers, json=data)
    result = handle_response(response)
    
    print("Profile updated successfully!")
    print(json.dumps(result, indent=2))
    return result

def change_password(args):
    """Change user password"""
    token = get_token()
    headers = {"Authorization": f"Bearer {token}"}
    
    data = {
        "currentPassword": args.current_password,
        "newPassword": args.new_password
    }
    
    print("Changing password...")
    response = requests.put(f"{API_URL}/profile", headers=headers, json=data)
    result = handle_response(response)
    
    print("Password changed successfully!")
    return result

def generate_recovery(args):
    """Generate new recovery key"""
    token = get_token()
    headers = {"Authorization": f"Bearer {token}"}
    
    data = {
        "currentPassword": args.current_password,
        "generateNewRecoveryKey": True
    }
    
    print("Generating new recovery key...")
    response = requests.put(f"{API_URL}/profile", headers=headers, json=data)
    result = handle_response(response)
    
    recovery_key = result.get('recoveryKey')
    print(f"New recovery key: {recovery_key}")
    return result

def reset_password(args):
    """Reset password with recovery key"""
    data = {
        "email": args.email,
        "recoveryKey": args.recovery_key,
        "newPassword": args.new_password
    }
    
    print("Resetting password...")
    response = requests.put(f"{API_URL}/forgot-password", json=data)
    result = handle_response(response)
    
    print("Password reset successfully!")
    return result

def delete_account(args):
    """Delete user account"""
    token = get_token()
    headers = {"Authorization": f"Bearer {token}"}
    
    data = {
        "password": args.password
    }
    
    print("WARNING: You are about to delete your account. This action cannot be undone.")
    confirm = input("Are you sure? (y/n): ")
    
    if confirm.lower() != 'y':
        print("Account deletion cancelled.")
        return
    
    print("Deleting account...")
    response = requests.delete(f"{API_URL}/profile", headers=headers, json=data)
    result = handle_response(response)
    
    print("Account deleted successfully!")
    
    # Remove token file
    if os.path.exists(TOKEN_FILE):
        os.remove(TOKEN_FILE)
    
    return result

def main():
    parser = argparse.ArgumentParser(description="Materio Auth CLI")
    subparsers = parser.add_subparsers(dest='command', help='Command to run')
    
    # Signup parser
    signup_parser = subparsers.add_parser('signup', help='Create a new user')
    signup_parser.add_argument('email', help='User email')
    signup_parser.add_argument('username', help='Username')
    signup_parser.add_argument('display_name', help='Display name')
    signup_parser.add_argument('password', help='Password')
    
    # Login parser
    login_parser = subparsers.add_parser('login', help='Login existing user')
    login_parser.add_argument('email', help='User email')
    login_parser.add_argument('password', help='Password')
    
    # Profile parser
    profile_parser = subparsers.add_parser('profile', help='Get user profile')
    
    # Update profile parser
    update_parser = subparsers.add_parser('update-profile', help='Update user profile')
    update_parser.add_argument('--username', help='New username')
    update_parser.add_argument('--display-name', help='New display name')
    
    # Change password parser
    change_pwd_parser = subparsers.add_parser('change-password', help='Change password')
    change_pwd_parser.add_argument('current_password', help='Current password')
    change_pwd_parser.add_argument('new_password', help='New password')
    
    # Generate recovery key parser
    gen_recovery_parser = subparsers.add_parser('gen-recovery', help='Generate new recovery key')
    gen_recovery_parser.add_argument('current_password', help='Current password')
    
    # Reset password parser
    reset_pwd_parser = subparsers.add_parser('reset-password', help='Reset password with recovery key')
    reset_pwd_parser.add_argument('email', help='User email')
    reset_pwd_parser.add_argument('recovery_key', help='Recovery key')
    reset_pwd_parser.add_argument('new_password', help='New password')
    
    # Delete account parser
    delete_parser = subparsers.add_parser('delete-account', help='Delete user account')
    delete_parser.add_argument('password', help='Current password')
    
    args = parser.parse_args()
    
    # Execute appropriate function based on command
    if args.command == 'signup':
        signup(args)
    elif args.command == 'login':
        login(args)
    elif args.command == 'profile':
        get_profile(args)
    elif args.command == 'update-profile':
        update_profile(args)
    elif args.command == 'change-password':
        change_password(args)
    elif args.command == 'gen-recovery':
        generate_recovery(args)
    elif args.command == 'reset-password':
        reset_password(args)
    elif args.command == 'delete-account':
        delete_account(args)
    else:
        parser.print_help()
        sys.exit(1)

if __name__ == "__main__":
    main()

Usage Examples

Using the Python Script

# Installation
chmod +x materio_auth.py

# Sign up
./materio_auth.py signup user@example.com username123 "User Name" secure-password

# Login
./materio_auth.py login user@example.com secure-password

# Get profile
./materio_auth.py profile

# Update profile
./materio_auth.py update-profile --username new_username --display-name "New Name"

# Change password
./materio_auth.py change-password current-password new-password

# Generate new recovery key
./materio_auth.py gen-recovery current-password

# Reset password with recovery key
./materio_auth.py reset-password user@example.com recovery-key-123 new-password

# Delete account
./materio_auth.py delete-account current-password

Security Considerations

1. Token Management: When using these scripts in production, store tokens securely.
2. Password Input: Consider using hidden input for passwords in production scripts.
3. Error Handling: Add proper error handling based on your specific needs.
4. Logging: Limit or disable logging of sensitive information in production.

These examples should help you integrate the authentication system with your existing tools and workflows.

OSI & TCP/IP Model Questions

1. What are the seven layers of the OSI model?
   • Physical – Transmission of raw data over the medium.
   • Data Link – Handles error detection and framing (e.g., MAC address).
   • Network – Manages routing and IP addressing.
   • Transport – Ensures reliable transmission (e.g., TCP, UDP).
   • Session – Establishes and maintains sessions between applications.
   • Presentation – Formats, encrypts, and compresses data.
   • Application – Provides network services to end users (e.g., HTTP, FTP).
2. Compare TCP and UDP.
   • TCP (Transmission Control Protocol): Reliable, connection-oriented, ensures data delivery (e.g., web browsing, email).
   • UDP (User Datagram Protocol): Unreliable, connectionless, faster, used in real-time applications (e.g., video streaming, VoIP).
3. What is encapsulation in networking?
   Encapsulation is the process of adding headers and trailers to data as it moves through the OSI layers before transmission.

IP Addressing & Routing

1. What is an IP address?
   An IP address is a numerical label assigned to a device for identification and communication over a network.

2. Differentiate between IPv4 and IPv6.
   • IPv4: 32-bit address, uses decimal notation, supports ~4.3 billion addresses.
   • IPv6: 128-bit address, uses hexadecimal notation, supports trillions of addresses.

3. What is a subnet mask?
   A subnet mask separates the network and host portions of an IP address to determine which devices belong to the same subnet.

4. What is the difference between static and dynamic IP addresses?
   • Static IP: Manually assigned, does not change, used in servers.
   • Dynamic IP: Assigned by DHCP (Dynamic Host Configuration Protocol), changes periodically.

5. What is a default gateway?
   A default gateway is a router that connects a local network to external networks, forwarding packets that need to reach other networks.

6. What is NAT (Network Address Translation)?
   NAT allows multiple devices on a local network to share a single public IP address, improving security and conserving IP addresses.

Networking Devices & Protocols

1. What is the function of a router?
   A router forwards data between different networks based on IP addresses.

2. What is a switch?
   A switch operates at the data link layer, directing data only to the intended recipient, improving efficiency over hubs.

3. What is the difference between a hub, switch, and router?
   • Hub: Broadcasts data to all devices in a network.
   • Switch: Sends data only to the intended device.
   • Router: Connects different networks and directs traffic based on IP addresses.

4. What is ARP (Address Resolution Protocol)?
   ARP maps an IP address to a MAC address for communication within a network.

5. What is DNS (Domain Name System)?
   DNS translates domain names (e.g., google.com) into IP addresses (e.g., 142.250.183.238).

6. What is DHCP (Dynamic Host Configuration Protocol)?
   DHCP automatically assigns IP addresses to devices in a network.

Security & Miscellaneous Questions

1. What is a firewall?
   A firewall is a security system that monitors and controls incoming and outgoing network traffic based on security rules.

2. What is a VPN (Virtual Private Network)?
   A VPN encrypts data and routes it through a secure server, masking the user’s actual IP address for privacy.

3. What is a proxy server?
   A proxy server acts as an intermediary between a user and the internet, often used for security, anonymity, or content filtering.

4. What is bandwidth?
   Bandwidth is the maximum data transfer rate of a network or internet connection, measured in bps (bits per second).

5. What is latency?
   Latency is the time taken for a data packet to travel from source to destination, usually measured in milliseconds (ms).

6. What is ping?
   Ping is a network command that tests the reachability of a host and measures round-trip time (RTT).

7. What is packet switching?
   Packet switching breaks data into packets that travel independently to their destination, allowing efficient and fast transmission (e.g., the Internet).

8. What is the difference between unicast, multicast, and broadcast?
   • Unicast – One-to-one communication.
   • Multicast – One-to-many (specific group).
   • Broadcast – One-to-all devices in a network.

9. What is a man-in-the-middle (MITM) attack?
   A MITM attack occurs when an attacker secretly intercepts and possibly alters communication between two parties.

10. What is a denial-of-service (DoS) attack?
    A DoS attack floods a network or server with excessive traffic to disrupt normal operation.

Bonus: Tricky Questions

1. Why is TCP more reliable than UDP?
   TCP provides error checking, retransmissions, congestion control, and three-way handshake, ensuring data is delivered correctly.

2. How does HTTPS work?
   HTTPS uses SSL/TLS encryption to secure communication between a client and a server, preventing eavesdropping and data tampering.

3. What happens when you type a URL in a browser and press Enter?

   • DNS resolves the domain name to an IP address.
   • Browser establishes a TCP connection with the server.
   • HTTP/HTTPS request is sent to the server.
   • Server responds with the requested webpage.
   • Browser renders the webpage.

Network Devices and OSI Layers

1. Which device operates at the Physical Layer (Layer 1)?
   • Hubs, Repeaters, Cables (Ethernet, Fiber Optic), and Network Interface Cards (NICs) work at the Physical Layer.
   • They deal with raw data transmission, signals, and bit representation.
2. Which device operates at the Data Link Layer (Layer 2)?
   • Switches and Bridges operate at the Data Link Layer.
   • They use MAC addresses for forwarding frames within a network.
3. Which device operates at the Network Layer (Layer 3)?
   • Routers and Layer 3 Switches operate at the Network Layer.
   • They use IP addresses for routing packets across different networks.
4. Which device operates at the Transport Layer (Layer 4)?
   • Firewalls and Load Balancers work at the Transport Layer.
   • They handle port numbers, segmentation, and flow control (e.g., TCP and UDP).
5. Which device operates at the Session Layer (Layer 5)?
   • Some Gateways and Proxies operate at the Session Layer.
   • They establish, maintain, and terminate communication sessions.
6. Which device operates at the Presentation Layer (Layer 6)?
   • Encryption/Decryption Devices (SSL/TLS) and Data Compressors work at the Presentation Layer.
   • They format data for compatibility and security.
7. Which device operates at the Application Layer (Layer 7)?
   • Web Servers, Email Servers, Proxies, and DNS Servers operate at the Application Layer.
   • They interact with end-user applications like browsers, email clients, and file transfers.

More Layer-Specific Questions

1. What is the role of a repeater in networking?
   • A repeater regenerates and amplifies weak signals to extend transmission distances.
   • It operates at Layer 1 (Physical Layer).
2. What is the main function of a switch?
   • A switch intelligently forwards data to the correct device using MAC addresses.
   • It operates at Layer 2 (Data Link Layer).
3. How does a router differ from a switch?
   • A router operates at Layer 3 (Network Layer) and routes packets based on IP addresses.
   • A switch operates at Layer 2 (Data Link Layer) and forwards frames using MAC addresses.
4. What is a Layer 3 switch?
   • A Layer 3 switch performs both switching (Layer 2) and routing (Layer 3) functions.
   • It allows communication between different subnets.
5. How does a firewall work, and at which layer does it operate?
   • A firewall monitors and filters incoming/outgoing traffic based on security rules.
   • It primarily operates at Layer 4 (Transport Layer) but can extend to Layer 7 (Application Layer) in advanced configurations.
6. What is the function of a proxy server, and which OSI layer does it belong to?
   • A proxy server acts as an intermediary between clients and servers, providing caching, security, and anonymity.
   • It operates at Layer 7 (Application Layer).
7. At which layer does NAT (Network Address Translation) work?
   • NAT operates at Layer 3 (Network Layer) because it modifies IP addresses for internet access.
8. What layer does DNS work in?
   • DNS (Domain Name System) works at Layer 7 (Application Layer) because it translates domain names into IP addresses.
9. At which OSI layer does SSL/TLS encryption work?
   • SSL/TLS encryption operates at Layer 6 (Presentation Layer) for encryption and decryption.

Tricky Layer Questions

1. Can a device work at multiple OSI layers?
   • Yes, some devices like firewalls, proxies, and gateways operate at multiple layers.
2. What is the highest OSI layer that a switch can operate at?
   • A basic switch operates at Layer 2, but Layer 3 switches can function at the Network Layer.
3. What happens if a router fails?
   • Network packets cannot be forwarded between different networks, breaking external communication.
4. Why are hubs considered obsolete?
   • Hubs send data to all devices, causing network congestion, whereas switches send data only to intended recipients.

This should cover all the must-know viva questions about network devices and OSI layers. Let me know if you need more! 🚀

HUGE thanks to O’Reilly for making this resource free.

2017 Design Salary Survey: Tools, Trends, Titles, What Pays (and What Doesn’t) for Design Professionals

Download PDF

Pair Design: Better Together

Download PDF

Design Frontiers: How Voice, Sound, Wearables, Sustainability, and Other Factors Will Shape Experiences

Download PDF

Designing for Mixed Reality: Blending Data, AR, and the Physical World

Download PDF

Design in Venture Capital: How Design Drives Investment and Company Success

Download PDF

Machine Learning for Designers

Download PDF

Design Essentials: A Curated Collection of Chapters from the O’Reilly Design Library

Download PDF

Designing for Product Strategy: A Curated Collection of Chapters from the O’Reilly Design Library

Download PDF

Prototyping for Physical and Digital Products

Download PDF

Designing for Cities: Technology and the Urban Experience

Download PDF

Designing for the Future: A Curated Collection of Chapters from the O’Reilly Library

Download PDF

Designing for Respect: UX Ethics for the Digital Age

Download PDF

Design for Voice Interfaces: Building Products that Talk

Download PDF

Experience Design: A Curated Collection of Chapters from the O’Reilly Design Library

Download PDF

Designing for the Internet of Things

Download PDF

User Experience Design for the Internet of Things: Why It’s More than UI and Industrial Design

Download PDF

Design and Business: A Curated Collection of Chapters from the O’Reilly Design Library

Download PDF

1. Introduction
2. Basics
3. Data Types
4. Control Flow
5. Functions
6. Modules
7. File Handling
8. Object-Oriented Programming
9. Error Handling
10. Common Built-in Functions
11. Advanced Topics

Introduction

Python is a high-level, versatile programming language known for its simplicity and readability. You can use Python for web development, data analysis, artificial intelligence, and much more.

Basics

Printing and Comments

Printing is used to display output:

print("Hello, World!")  # This prints Hello, World! to the screen

Comments are notes for the programmer and ignored by Python:

# This is a single-line comment

'''
This is a
multi-line comment
'''

Variables

Variables store data. You don’t need to specify the type of a variable.

x = 5         # Integer
y = 3.14      # Float
name = "John" # String
is_happy = True  # Boolean

# You can print variables like this:
print("Name:", name)

Rules for Variable Names

• Must start with a letter or an underscore.
• Can only contain letters, numbers, and underscores.
• Case-sensitive (Name and name are different).

Input

The input function takes user input as a string:

user_name = input("What is your name? ")
print(f"Nice to meet you, {user_name}!")

Data Types

Python has several data types to store different kinds of data.

Numbers

a = 10      # Integer
b = 3.14    # Float
c = 2 + 3j  # Complex number

Strings

Strings are text data enclosed in quotes:

text = "Hello"
print(text.upper())  # Convert to uppercase
print(text[1])       # Access character at index 1

String Concatenation:

first = "Hello"
second = "World"
combined = first + " " + second
print(combined)

String Formatting:

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

Lists

Lists are ordered collections of items.

numbers = [1, 2, 3, 4]
print(numbers[0])    # Access first item
numbers.append(5)    # Add an item
numbers.pop()        # Remove last item
print(numbers)

Dictionaries

Dictionaries store data in key-value pairs.

person = {"name": "Alice", "age": 25}
print(person["name"])  # Access value by key
person["age"] = 26     # Update value
print(person)

Tuples

Tuples are immutable lists (cannot be changed after creation).

coordinates = (10, 20)
print(coordinates[0])

Sets

Sets are collections of unique items.

unique_items = {1, 2, 3, 2}
unique_items.add(4)
print(unique_items)  # Output: {1, 2, 3, 4}

Control Flow

Control flow determines the order in which code runs.

If-Else

age = 18
if age >= 18:
    print("You are an adult.")
elif age > 13:
    print("You are a teenager.")
else:
    print("You are a child.")

Loops

For Loop:

for i in range(5):
    print(i)  # Outputs 0, 1, 2, 3, 4

While Loop:

count = 0
while count < 5:
    print(count)
    count += 1

Functions

Functions group reusable code.

Defining Functions

def greet(name):
    return f"Hello, {name}!"
print(greet("Alice"))

Default Parameters

def greet(name="stranger"):
    return f"Hello, {name}!"
print(greet())  # Outputs: Hello, stranger!

Modules

Modules are libraries of code you can import.

Importing Modules

import math
print(math.sqrt(16))

Installing External Modules

Use pip to install libraries:

pip install requests

File Handling

Reading and Writing Files

# Write to a file
with open("example.txt", "w") as file:
    file.write("Hello, file!")

# Read from a file
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Object-Oriented Programming

OOP allows you to model real-world things using classes and objects.

Classes and Objects

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return f"{self.name} says Woof!"

dog = Dog("Buddy", "Golden Retriever")
print(dog.bark())

Error Handling

Handle errors gracefully with try-except blocks.

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
finally:
    print("Done!")

Common Built-in Functions

Math Functions

max([1, 2, 3])  # Find max
min([1, 2, 3])  # Find min
abs(-10)        # Absolute value
sum([1, 2, 3])  # Sum of elements

String Functions

len("hello")          # String length
"hello".replace("e", "a")  # Replace characters

Advanced Topics

List Comprehensions

squares = [x**2 for x in range(5)]
print(squares)

Lambda Functions

double = lambda x: x * 2
print(double(5))

© Materio 2024

#Getting started

public class Hello {
  // main method
  public static void main(String[] args)
  {
    // Output: Hello, world!
    System.out.println("Hello, world!");
  }
}

compiling and running
$ javac Hello.java
$ java Hello
Hello, world!

variables

int num = 5;
float floatNum = 5.99f;
char letter = 'D';
boolean bool = true;
String site = "quickref.me";

Primitive data types

Type Casting

// Widening
// byte<short<int<long<float<double
int i = 10;
long l = i;               // 10

// Narrowing
double d = 10.02;
long l = (long)d;         // 10

String.valueOf(10);       // "10"
Integer.parseInt("10");   // 10
Double.parseDouble("10"); // 10.0

User Input

Scanner in = new Scanner(System.in);
String str = in.nextLine();
System.out.println(str);

int num = in.nextInt();
System.out.println(num);

Java Strings

Basic

String str1 = "value";
String str2 = new String("value");
String str3 = String.valueOf(123);

concatenation

String s = 3 + "str" + 3;     // 3str3
String s = 3 + 3 + "str";     // 6str
String s = "3" + 3 + "str";   // 33str
String s = "3" + "3" + "23";  // 3323
String s = "" + 3 + 3 + "23"; // 3323
String s = 3 + 3 + 23;        // 29

StringBuilder

StringBuilder sb = new StringBuilder(10);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
|   |   |   |   |   |   |   |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8  9

sb.append(“QuickRef”);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| Q | u | i | c | k | R | e | f |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.delete(5, 9);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| Q | u | i | c | k |   |   |   |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.insert(0, “My “);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y |   | Q | u | i | c | k |   |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

sb.append(“!”);

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
| M | y |   | Q | u | i | c | k | ! |
└───┴───┴───┴───┴───┴───┴───┴───┴───┘
0   1   2   3   4   5   6   7   8   9

Comparison

String s1 = new String("QuickRef");
String s2 = new String("QuickRef");

s1 == s2          // false
s1.equals(s2)     // true

"AB".equalsIgnoreCase("ab")  // true

manipulation

String str = "Abcd";

str.toUpperCase();     // ABCD
str.toLowerCase();     // abcd
str.concat("#");       // Abcd#
str.replace("b", "-"); // A-cd

"  abc ".trim();       // abc
"ab".toCharArray();    // {'a', 'b'}

information

String str = "abcd";

str.charAt(2);       // c
str.indexOf("a")     // 0
str.indexOf("z")     // -1
str.length();        // 4
str.toString();      // abcd
str.substring(2);    // cd
str.substring(2,3);  // c
str.contains("c");   // true
str.endsWith("d");   // true
str.startsWith("a"); // true
str.isEmpty();       // false

immutable

String str = "hello";
str.concat("world");

// Outputs: hello
System.out.println(str);

String str = "hello";
String concat = str.concat("world");

// Outputs: helloworld
System.out.println(concat);

Once created cannot be modified, any modification creates a new String

Java Arrays

Declare

int[] a1;
int[] a2 = {1, 2, 3};
int[] a3 = new int[]{1, 2, 3};

int[] a4 = new int[3];
a4[0] = 1;
a4[2] = 2;
a4[3] = 3;

modify

int[] a = {1, 2, 3};
System.out.println(a[0]); // 1

a[0] = 9;
System.out.println(a[0]); // 9

System.out.println(a.length); // 3

Loop (Read & Modify)

int[] arr = {1, 2, 3};
for (int i=0; i < arr.length; i++) {
    arr[i] = arr[i] * 2;
    System.out.print(arr[i] + " ");
}
// Outputs: 2 4 6

Loop (Read)

String[] arr = {"a", "b", "c"};
for (int a: arr) {
    System.out.print(a + " ");
}
// Outputs: a b c

multidimensional Arrays

int[][] matrix = { {1, 2, 3}, {4, 5} };

int x = matrix[1][0];  // 4
// [[1, 2, 3], [4, 5]]
Arrays.deepToString(matrix)

for (int i = 0; i < a.length; ++i) {
  for(int j = 0; j < a[i].length; ++j) {
    System.out.println(a[i][j]);
  }
}
// Outputs: 1 2 3 4 5 6 7

sort

char[] chars = {'b', 'a', 'c'};
Arrays.sort(chars);

// [a, b, c]
Arrays.toString(chars);

Java Conditional

if else

int k = 15;
if (k > 20) {
  System.out.println(1);
} else if (k > 10) {
  System.out.println(2);
} else {
  System.out.println(3);
}

switch

int month = 3;
String str;
switch (month) {
  case 1:
    str = "January";
    break;
  case 2:
    str = "February";
    break;
  case 3:
    str = "March";
    break;
  default:
    str = "Some other month";
    break;
}

// Outputs: Result March
System.out.println("Result " + str);

ternary operator

int a = 10;
int b = 20;
int max = (a > b) ? a : b;

// Outputs: 20
System.out.println(max);

Java loops

for loop

for (int i = 0; i < 10; i++) {
  System.out.print(i);
}
// Outputs: 0123456789

for (int i = 0,j = 0; i < 3; i++,j--) {
  System.out.print(j + "|" + i + " ");
}
// Outputs: 0|0 -1|1 -2|2

Enhanced For loop

int[] numbers = {1,2,3,4,5};

for (int number: numbers) {
  System.out.print(number);
}
// Outputs: 12345

Used to loop around array’s or List’s

while loop

int count = 0;

while (count < 5) {
  System.out.print(count);
  count++;
}
// Outputs: 01234

Do While Loop

int count = 0;

do {
  System.out.print(count);
  count++;
} while (count < 5);
// Outputs: 01234

continue statement

for (int i = 0; i < 5; i++) {
  if (i == 3) {
    continue;
  }
  System.out.print(i);
}
// Outputs: 01245

break statement

for (int i = 0; i < 5; i++) {
  System.out.print(i);
  if (i == 3) {
    break;
  }
}
// Outputs: 0123

most imp

JCF(Java collection Framework):

1. List Interface Ordered collection (also known as a sequence).

• ArrayList: Resizable array implementation.

List<String> list = new ArrayList<>();
list.add("Element");
list.get(0);
list.size();
list.remove(0);

• LinkedList: Doubly-linked list implementation.

List<String> list = new LinkedList<>();
list.add("Element");
list.get(0);
list.size();
list.remove(0);

1. Set Interface Collection that cannot contain duplicate elements.

• HashSet: Hash table implementation.

Set<String> set = new HashSet<>();
set.add("Element");
set.contains("Element");
set.size();
set.remove("Element");

• LinkedHashSet: Hash table and linked list implementation (orders elements by insertion order).

Set<String> set = new LinkedHashSet<>();
set.add("Element");
set.contains("Element");
set.size();
set.remove("Element");

• TreeSet: Red-black tree implementation (orders elements based on their values).

Set<String> set = new TreeSet<>();
set.add("Element");
set.contains("Element");
set.size();
set.remove("Element");

1. Queue Interface Collection designed for holding elements prior to processing.

• LinkedList (also implements Queue interface):

Queue<String> queue = new LinkedList<>();
queue.add("Element");
queue.offer("Element"); // Similar to add but does not throw exception
queue.peek(); // Retrieves, but does not remove, the head of this queue
queue.poll(); // Retrieves and removes the head of this queue

• PriorityQueue: Priority heap implementation (orders elements based on their natural ordering or by a Comparator provided at queue construction time).

Queue<String> queue = new PriorityQueue<>();
queue.add("Element");
queue.offer("Element");
queue.peek();
queue.poll();

1. Deque Interface Double-ended queue, supports element insertion and removal at both ends.

• ArrayDeque: Resizable array implementation of Deque.

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("Element");
deque.addLast("Element");
deque.offerFirst("Element");
deque.offerLast("Element");
deque.peekFirst();
deque.peekLast();
deque.pollFirst();
deque.pollLast();

1. Map Interface Object that maps keys to values; cannot contain duplicate keys.

• HashMap: Hash table implementation.

Map<String, String> map = new HashMap<>();
map.put("key", "value");
map.get("key");
map.containsKey("key");
map.size();
map.remove("key");

• LinkedHashMap: Hash table and linked list implementation (orders elements by insertion order).

Map<String, String> map = new LinkedHashMap<>();
map.put("key", "value");
map.get("key");
map.containsKey("key");
map.size();
map.remove("key");

• TreeMap: Red-black tree implementation (orders elements based on their natural ordering or by a Comparator provided at map construction time).

Map<String, String> map = new TreeMap<>();
map.put("key", "value");
map.get("key");
map.containsKey("key");
map.size();
map.remove("key");

1. Stack Class Last-In-First-Out (LIFO) stack of objects.

Stack<String> stack = new Stack<>();
stack.push("Element");
stack.peek(); // Looks at the object at the top of this stack without removing it
stack.pop(); // Removes the object at the top of this stack and returns that object
stack.isEmpty(); // Tests if this stack is empty

Additional Methods and Tips

• Iteration over Collections:

// Using Iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// Using enhanced for-loop
for (String element : list) {
    System.out.println(element);
}

• sorting Lists:

Collections.sort(list);
Collections.sort(list, Comparator.reverseOrder());

Java Interview questions for Freshers

Source