Programming on QuickRef - Personal Developer Reference

Bash

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Bash (Bourne Again SHell) is a Unix shell and command language. It’s the default shell on most Linux systems and macOS, and is widely used for system administration and automation.

Variables

# Variable assignment (no spaces around =)
name="value"
number=42

# Using variables
echo $name
echo ${name}
echo "Hello $name"

Special Variables

$0 - Script name
$1, $2, ... - Script arguments
$# - Number of arguments
$@ - All arguments
$? - Exit status of last command
$$ - Process ID
$! - Process ID of last background command

String Operations

# String length
${#string}

# Substring
${string:position:length}

# Replace
${string/old/new} # Replace first occurrence
${string//old/new} # Replace all occurrences

# Remove prefix/suffix
${string#prefix} # Remove shortest prefix
${string##prefix} # Remove longest prefix
${string%suffix} # Remove shortest suffix
${string%%suffix} # Remove longest suffix

Arrays

# Array declaration
arr=("item1" "item2" "item3")

# Access elements
echo ${arr[0]} # First element
echo ${arr[@]} # All elements
echo ${#arr[@]} # Array length

# Add elements
arr+=("item4")

Conditionals

if [ condition ]; then
 # commands
elif [ condition ]; then
 # commands
else
 # commands
fi

Test Conditions

# File tests
[ -f file ] # File exists
[ -d directory ] # Directory exists
[ -r file ] # File is readable
[ -w file ] # File is writable
[ -x file ] # File is executable

# String tests
[ -z string ] # String is empty
[ -n string ] # String is not empty
[ string1 = string2 ] # Strings are equal
[ string1 != string2 ] # Strings are not equal

# Numeric tests
[ num1 -eq num2 ] # Equal
[ num1 -ne num2 ] # Not equal
[ num1 -gt num2 ] # Greater than
[ num1 -lt num2 ] # Less than
[ num1 -ge num2 ] # Greater than or equal
[ num1 -le num2 ] # Less than or equal

Loops

For Loop

# Loop through list
for item in item1 item2 item3; do
 echo $item
done

# Loop through range
for i in {1..10}; do
 echo $i
done

# C-style loop
for ((i=1; i<=10; i++)); do
 echo $i
done

# Loop through files
for file in *.txt; do
 echo $file
done

While Loop

while [ condition ]; do
 # commands
done

# Reading file line by line
while IFS= read -r line; do
 echo "$line"
done < file.txt

Until Loop

until [ condition ]; do
 # commands
done

Functions

# Function definition
function_name() {
 # commands
 echo "Parameter 1: $1"
 echo "Parameter 2: $2"
 return 0
}

# Call function
function_name arg1 arg2

# Function with local variables
my_function() {
 local local_var="local value"
 echo $local_var
}

Input/Output

# Read user input
read -p "Enter your name: " name
echo "Hello $name"

# Read with options
read -s password # Silent input
read -t 10 input # Timeout after 10 seconds
read -n 1 char # Read single character

File Operations

# Check if file exists
if [ -f "file.txt" ]; then
 echo "File exists"
fi

# Create file
touch file.txt

# Write to file
echo "content" > file.txt # Overwrite
echo "content" >> file.txt # Append

# Read file
while IFS= read -r line; do
 echo "$line"
done < file.txt

Process Control

# Run in background
command &

# Wait for background jobs
wait

# Kill process
kill PID
killall process_name

# Check if process is running
if pgrep process_name > /dev/null; then
 echo "Process is running"
fi

Error Handling

# Exit on error
set -e

# Check command success
if command; then
 echo "Success"
else
 echo "Failed"
fi

# Short-circuit evaluation
command && echo "Success" || echo "Failed"

Advanced Features

Command Substitution

# Modern syntax
result=$(command)

# Legacy syntax
result=`command`

# Examples
current_date=$(date)
file_count=$(ls | wc -l)

Parameter Expansion

# Default values
${variable:-default} # Use default if variable is unset
${variable:=default} # Set variable to default if unset
${variable:+alternate} # Use alternate if variable is set
${variable:?error} # Exit with error if variable is unset

Arithmetic

# Arithmetic expansion
result=$((5 + 3))
result=$((variable * 2))

# Increment/decrement
((counter++))
((counter--))

Best Practices

Always quote variables: "$variable"
Use #!/bin/bash as the first line
Set set -e to exit on errors
Use set -u to exit on undefined variables
Use shellcheck to validate scripts
Use meaningful variable names
Add comments for complex logic

Common Patterns

Argument Parsing

while [[ $# -gt 0 ]]; do
 case $1 in
 -h|--help)
 echo "Usage: $0 [options]"
 exit 0
 ;;
 -v|--verbose)
 verbose=true
 shift
 ;;
 *)
 echo "Unknown option: $1"
 exit 1
 ;;
 esac
done

Script Template

#!/bin/bash
set -euo pipefail

# Script description
# Usage: script.sh [options] arguments

# Default values
verbose=false
dry_run=false

# Functions
usage() {
 echo "Usage: $0 [options] arguments"
 echo "Options:"
 echo " -h, --help Show this help"
 echo " -v, --verbose Verbose output"
 echo " -n, --dry-run Dry run mode"
}

main() {
 # Main script logic
 echo "Script starting..."
}

# Parse arguments
while [[ $# -gt 0 ]]; do
 case $1 in
 -h|--help)
 usage
 exit 0
 ;;
 -v|--verbose)
 verbose=true
 shift
 ;;
 -n|--dry-run)
 dry_run=true
 shift
 ;;
 *)
 echo "Unknown option: $1"
 usage
 exit 1
 ;;
 esac
done

# Run main function
main "$@"

C

Sun, 01 Jan 2023 00:00:00 +0000

Overview

C is a general-purpose programming language that provides low-level access to memory and system resources. It’s the foundation for many operating systems, embedded systems, and performance-critical applications.

Installation

Compilers

# GCC (GNU Compiler Collection)
sudo apt install gcc # Ubuntu/Debian
brew install gcc # macOS
sudo yum install gcc # CentOS/RHEL

# Clang
sudo apt install clang # Ubuntu/Debian
brew install llvm # macOS

# Microsoft Visual Studio (Windows)
# Download from https://visualstudio.microsoft.com/

Build Tools

# Make
sudo apt install make # Usually pre-installed

# GDB (GNU Debugger)
sudo apt install gdb # Ubuntu/Debian
brew install gdb # macOS

Basic Syntax

Hello World

#include <stdio.h>

int main() {
 printf("Hello, World!\n");
 return 0;
}

Compilation

# Basic compilation
gcc -o program program.c

# With debugging info
gcc -g -o program program.c

# With warnings
gcc -Wall -Wextra -o program program.c

# C standard version
gcc -std=c99 -o program program.c

Data Types

Primitive Types

// Integer types
int num = 42;
short s = 10;
long l = 1000000L;
long long ll = 1000000000LL;

// Unsigned types
unsigned int u = 42U;
unsigned short us = 10U;
unsigned long ul = 1000000UL;
unsigned long long ull = 1000000000ULL;

// Floating point
float f = 3.14f;
double d = 3.14159;
long double ld = 3.141592653589793L;

// Character
char c = 'A';
unsigned char uc = 255;

// Boolean (C99)
#include <stdbool.h>
bool flag = true;

Size Information

#include <stdio.h>
#include <limits.h>

int main() {
 printf("Size of int: %zu bytes\n", sizeof(int));
 printf("Size of long: %zu bytes\n", sizeof(long));
 printf("Size of float: %zu bytes\n", sizeof(float));
 printf("Size of double: %zu bytes\n", sizeof(double));
 
 printf("INT_MAX: %d\n", INT_MAX);
 printf("INT_MIN: %d\n", INT_MIN);
 
 return 0;
}

Constants and Macros

#include <stdio.h>

#define PI 3.14159
#define MAX_SIZE 100
#define SQUARE(x) ((x) * (x))

const int BUFFER_SIZE = 1024;

// Enumeration
enum Color {
 RED,
 GREEN,
 BLUE
};

enum Status {
 ACTIVE = 1,
 INACTIVE = 0,
 PENDING = -1
};

Variables and Scope

Variable Declaration

int x; // Declaration
int y = 10; // Initialization
int z = 0; // Always initialize

// Multiple declarations
int a = 1, b = 2, c = 3;

// Storage classes
auto int local_var = 10; // Default for local variables
static int static_var = 20; // Retains value between calls
extern int global_var; // Declared elsewhere
register int fast_var = 30; // Hint for compiler optimization

Scope

int global_var = 10; // Global scope

void function() {
 static int count = 0; // Static local variable
 count++;
 printf("Count: %d\n", count);
}

int main() {
 int local_var = 20; // Local scope
 
 {
 int block_var = 30; // Block scope
 printf("Block var: %d\n", block_var);
 }
 // block_var is not accessible here
 
 return 0;
}

Functions

Function Declaration and Definition

// Function prototype
int add(int a, int b);
void print_message(void);

// Function definition
int add(int a, int b) {
 return a + b;
}

void print_message(void) {
 printf("Hello from function!\n");
}

// Function with no return value
void swap(int *a, int *b) {
 int temp = *a;
 *a = *b;
 *b = temp;
}

Function Pointers

// Function pointer declaration
int (*operation)(int, int);

// Functions to point to
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
 operation = add;
 printf("5 + 3 = %d\n", operation(5, 3));
 
 operation = multiply;
 printf("5 * 3 = %d\n", operation(5, 3));
 
 return 0;
}

Variadic Functions

#include <stdarg.h>

int sum(int count, ...) {
 va_list args;
 va_start(args, count);
 
 int total = 0;
 for (int i = 0; i < count; i++) {
 total += va_arg(args, int);
 }
 
 va_end(args);
 return total;
}

int main() {
 printf("Sum: %d\n", sum(3, 10, 20, 30));
 return 0;
}

Control Structures

Conditionals

// if-else
if (x > 0) {
 printf("Positive\n");
} else if (x < 0) {
 printf("Negative\n");
} else {
 printf("Zero\n");
}

// Ternary operator
int result = (x > 0) ? 1 : -1;

// Switch statement
switch (choice) {
 case 1:
 printf("Option 1\n");
 break;
 case 2:
 printf("Option 2\n");
 break;
 case 3:
 case 4:
 printf("Option 3 or 4\n");
 break;
 default:
 printf("Invalid option\n");
}

Loops

// for loop
for (int i = 0; i < 10; i++) {
 printf("%d ", i);
}

// while loop
int i = 0;
while (i < 10) {
 printf("%d ", i);
 i++;
}

// do-while loop
int j = 0;
do {
 printf("%d ", j);
 j++;
} while (j < 10);

// Loop control
for (int i = 0; i < 10; i++) {
 if (i == 5) continue; // Skip iteration
 if (i == 8) break; // Exit loop
 printf("%d ", i);
}

Arrays and Strings

Arrays

// Array declaration and initialization
int numbers[5] = {1, 2, 3, 4, 5};
int values[] = {10, 20, 30}; // Size inferred
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// Array access
for (int i = 0; i < 5; i++) {
 printf("%d ", numbers[i]);
}

// Array size
int size = sizeof(numbers) / sizeof(numbers[0]);

Strings

#include <string.h>

// String declaration
char str1[20] = "Hello";
char str2[] = "World";
char *str3 = "C Programming";

// String functions
int len = strlen(str1);
strcpy(str1, "New string");
strcat(str1, " appended");
int cmp = strcmp(str1, str2);

// String input/output
char buffer[100];
printf("Enter a string: ");
fgets(buffer, sizeof(buffer), stdin);
printf("You entered: %s", buffer);

String Manipulation

#include <string.h>
#include <ctype.h>

// Convert to uppercase
void to_upper(char *str) {
 while (*str) {
 *str = toupper(*str);
 str++;
 }
}

// Find substring
char *find_substr(char *haystack, char *needle) {
 return strstr(haystack, needle);
}

// Split string
void split_string(char *str, char delimiter) {
 char *token = strtok(str, &delimiter);
 while (token != NULL) {
 printf("%s\n", token);
 token = strtok(NULL, &delimiter);
 }
}

Pointers

Basic Pointers

int x = 10;
int *ptr = &x; // Pointer to x
int value = *ptr; // Dereference pointer

printf("Value: %d\n", value);
printf("Address: %p\n", (void*)ptr);

// Null pointer
int *null_ptr = NULL;
if (null_ptr == NULL) {
 printf("Pointer is null\n");
}

Pointer Arithmetic

int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr; // Points to first element

// Pointer arithmetic
ptr++; // Move to next element
ptr += 2; // Move 2 elements forward
ptr--; // Move to previous element

// Array traversal using pointers
int *start = arr;
int *end = arr + 5;
while (start < end) {
 printf("%d ", *start);
 start++;
}

Pointers and Functions

// Pass by reference
void increment(int *num) {
 (*num)++;
}

// Return pointer from function
int* get_max(int *a, int *b) {
 return (*a > *b) ? a : b;
}

// Array as function parameter
void print_array(int arr[], int size) {
 for (int i = 0; i < size; i++) {
 printf("%d ", arr[i]);
 }
}

Double Pointers

int x = 10;
int *ptr = &x;
int **double_ptr = &ptr;

printf("Value: %d\n", **double_ptr);
printf("Address of x: %p\n", (void*)ptr);
printf("Address of ptr: %p\n", (void*)double_ptr);

Memory Management

Dynamic Memory Allocation

#include <stdlib.h>

// malloc - allocate memory
int *ptr = (int*)malloc(5 * sizeof(int));
if (ptr == NULL) {
 printf("Memory allocation failed\n");
 return 1;
}

// Initialize allocated memory
for (int i = 0; i < 5; i++) {
 ptr[i] = i + 1;
}

// calloc - allocate and initialize to zero
int *arr = (int*)calloc(5, sizeof(int));

// realloc - resize memory
ptr = (int*)realloc(ptr, 10 * sizeof(int));

// free - deallocate memory
free(ptr);
free(arr);
ptr = NULL; // Avoid dangling pointer
arr = NULL;

Memory Management Best Practices

// Check for allocation failure
void* safe_malloc(size_t size) {
 void *ptr = malloc(size);
 if (ptr == NULL) {
 fprintf(stderr, "Memory allocation failed\n");
 exit(1);
 }
 return ptr;
}

// Always free allocated memory
void process_data() {
 int *data = (int*)malloc(100 * sizeof(int));
 if (data == NULL) return;
 
 // Process data...
 
 free(data);
 data = NULL;
}

Structures and Unions

Structures

// Structure definition
struct Person {
 char name[50];
 int age;
 float salary;
};

// Structure usage
struct Person person1 = {"John Doe", 30, 50000.0};
struct Person person2;

// Accessing members
strcpy(person2.name, "Jane Smith");
person2.age = 25;
person2.salary = 45000.0;

// Pointer to structure
struct Person *ptr = &person1;
printf("Name: %s\n", ptr->name);
printf("Age: %d\n", ptr->age);

Typedef

// Define structure with typedef
typedef struct {
 int x;
 int y;
} Point;

// Usage
Point p1 = {10, 20};
Point p2 = {0}; // Initialize to zero

// Function with structure
double distance(Point p1, Point p2) {
 int dx = p1.x - p2.x;
 int dy = p1.y - p2.y;
 return sqrt(dx*dx + dy*dy);
}

Unions

union Data {
 int i;
 float f;
 char str[20];
};

union Data data;
data.i = 10;
printf("Integer: %d\n", data.i);

data.f = 3.14;
printf("Float: %.2f\n", data.f);

strcpy(data.str, "Hello");
printf("String: %s\n", data.str);

Bit Fields

struct Flags {
 unsigned int flag1 : 1;
 unsigned int flag2 : 1;
 unsigned int flag3 : 1;
 unsigned int reserved : 5;
};

struct Flags flags = {0};
flags.flag1 = 1;
flags.flag2 = 0;
flags.flag3 = 1;

File I/O

File Operations

#include <stdio.h>

// Open file
FILE *file = fopen("input.txt", "r");
if (file == NULL) {
 perror("Error opening file");
 return 1;
}

// Read from file
char buffer[100];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
 printf("%s", buffer);
}

// Close file
fclose(file);

File Modes

// File modes
FILE *read_file = fopen("file.txt", "r"); // Read
FILE *write_file = fopen("file.txt", "w"); // Write (truncate)
FILE *append_file = fopen("file.txt", "a"); // Append
FILE *read_write = fopen("file.txt", "r+"); // Read/Write
FILE *binary_file = fopen("file.bin", "rb"); // Binary read

Formatted I/O

// Writing formatted data
FILE *file = fopen("output.txt", "w");
fprintf(file, "Name: %s, Age: %d, Salary: %.2f\n", "John", 30, 50000.0);
fclose(file);

// Reading formatted data
FILE *file = fopen("input.txt", "r");
char name[50];
int age;
float salary;
fscanf(file, "Name: %s, Age: %d, Salary: %f", name, &age, &salary);
fclose(file);

Binary I/O

// Write binary data
struct Person person = {"John", 30, 50000.0};
FILE *file = fopen("person.bin", "wb");
fwrite(&person, sizeof(struct Person), 1, file);
fclose(file);

// Read binary data
struct Person read_person;
FILE *file = fopen("person.bin", "rb");
fread(&read_person, sizeof(struct Person), 1, file);
fclose(file);

Preprocessor

Macros

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define SWAP(a, b) do { \
 typeof(a) temp = a; \
 a = b; \
 b = temp; \
} while(0)

// Conditional compilation
#ifdef DEBUG
 #define DBG_PRINT(x) printf("DEBUG: %s\n", x)
#else
 #define DBG_PRINT(x)
#endif

// Predefined macros
printf("File: %s\n", __FILE__);
printf("Line: %d\n", __LINE__);
printf("Function: %s\n", __func__);
printf("Date: %s\n", __DATE__);
printf("Time: %s\n", __TIME__);

Header Guards

// header.h
#ifndef HEADER_H
#define HEADER_H

// Header content here

#endif // HEADER_H

Include Files

#include <stdio.h> // Standard library
#include <stdlib.h> // Standard library
#include <string.h> // String functions
#include <math.h> // Math functions
#include <time.h> // Time functions
#include "myheader.h" // User-defined header

Error Handling

Error Codes

#include <errno.h>

int divide(int a, int b, int *result) {
 if (b == 0) {
 return -1; // Error code
 }
 *result = a / b;
 return 0; // Success
}

int main() {
 int result;
 if (divide(10, 0, &result) != 0) {
 printf("Error: Division by zero\n");
 }
 return 0;
}

Error Messages

#include <errno.h>
#include <string.h>

FILE *file = fopen("nonexistent.txt", "r");
if (file == NULL) {
 fprintf(stderr, "Error opening file: %s\n", strerror(errno));
 return 1;
}

Assert

#include <assert.h>

void process_array(int *arr, int size) {
 assert(arr != NULL);
 assert(size > 0);
 
 // Process array...
}

Standard Library

Common Functions

// String functions
#include <string.h>
strlen(str) // String length
strcpy(dest, src) // Copy string
strcat(dest, src) // Concatenate strings
strcmp(str1, str2) // Compare strings
strstr(haystack, needle) // Find substring

// Memory functions
memset(ptr, value, size) // Set memory
memcpy(dest, src, size) // Copy memory
memmove(dest, src, size) // Move memory
memcmp(ptr1, ptr2, size) // Compare memory

// Math functions
#include <math.h>
sqrt(x) // Square root
pow(x, y) // Power
sin(x) // Sine
cos(x) // Cosine
log(x) // Natural logarithm

Character Functions

#include <ctype.h>

isalpha(c) // Is alphabetic
isdigit(c) // Is digit
isalnum(c) // Is alphanumeric
isspace(c) // Is whitespace
isupper(c) // Is uppercase
islower(c) // Is lowercase
toupper(c) // Convert to uppercase
tolower(c) // Convert to lowercase

Common Patterns

Linked List

typedef struct Node {
 int data;
 struct Node *next;
} Node;

Node* create_node(int data) {
 Node *node = (Node*)malloc(sizeof(Node));
 node->data = data;
 node->next = NULL;
 return node;
}

void insert_at_head(Node **head, int data) {
 Node *new_node = create_node(data);
 new_node->next = *head;
 *head = new_node;
}

void print_list(Node *head) {
 while (head != NULL) {
 printf("%d -> ", head->data);
 head = head->next;
 }
 printf("NULL\n");
}

Generic Programming with void*

// Generic stack implementation
typedef struct {
 void **data;
 int top;
 int capacity;
 size_t element_size;
} Stack;

Stack* create_stack(int capacity, size_t element_size) {
 Stack *stack = (Stack*)malloc(sizeof(Stack));
 stack->data = (void**)malloc(capacity * sizeof(void*));
 stack->top = -1;
 stack->capacity = capacity;
 stack->element_size = element_size;
 return stack;
}

int push(Stack *stack, void *element) {
 if (stack->top >= stack->capacity - 1) {
 return 0; // Stack full
 }
 
 void *copy = malloc(stack->element_size);
 memcpy(copy, element, stack->element_size);
 stack->data[++stack->top] = copy;
 return 1; // Success
}

Debugging

GDB Usage

# Compile with debug information
gcc -g -o program program.c

# Run with GDB
gdb ./program

# GDB commands
(gdb) break main # Set breakpoint
(gdb) run # Run program
(gdb) next # Next line
(gdb) step # Step into function
(gdb) print variable # Print variable value
(gdb) continue # Continue execution
(gdb) quit # Exit GDB

Debug Prints

#ifdef DEBUG
 #define DEBUG_PRINT(fmt, ...) \
 fprintf(stderr, "DEBUG: %s:%d: " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
#else
 #define DEBUG_PRINT(fmt, ...)
#endif

int main() {
 int x = 10;
 DEBUG_PRINT("x = %d\n", x);
 return 0;
}

Best Practices

Code Organization

// Function prototypes at top
int add(int a, int b);
void print_array(int arr[], int size);

// Constants and macros
#define MAX_SIZE 100
const int BUFFER_SIZE = 1024;

// Main function
int main() {
 // Variable declarations at top of function
 int result;
 int numbers[MAX_SIZE];
 
 // Code logic
 result = add(5, 3);
 
 return 0;
}

// Function implementations
int add(int a, int b) {
 return a + b;
}

Memory Safety

// Always check malloc return
int *ptr = (int*)malloc(sizeof(int) * 10);
if (ptr == NULL) {
 // Handle allocation failure
 return -1;
}

// Always free allocated memory
free(ptr);
ptr = NULL; // Avoid dangling pointer

// Use const for read-only data
void print_string(const char *str) {
 printf("%s\n", str);
}

Error Handling

// Return error codes
int safe_divide(int a, int b, int *result) {
 if (b == 0) {
 return -1; // Error
 }
 *result = a / b;
 return 0; // Success
}

// Check return values
if (safe_divide(10, 2, &result) != 0) {
 printf("Error in division\n");
}

Performance Tips

Optimization

// Use appropriate data types
uint8_t small_number = 255; // Instead of int for small values

// Use register hint for frequently used variables
register int i;
for (i = 0; i < 1000000; i++) {
 // Loop body
}

// Minimize function calls in loops
int len = strlen(str);
for (int i = 0; i < len; i++) {
 // Process str[i]
}

Memory Optimization

// Align structures for better performance
struct AlignedStruct {
 char a; // 1 byte
 char pad[3]; // 3 bytes padding
 int b; // 4 bytes
 double c; // 8 bytes
};

// Use bit fields for flags
struct Flags {
 unsigned int flag1 : 1;
 unsigned int flag2 : 1;
 unsigned int flag3 : 1;
 unsigned int reserved : 5;
};

Build Systems

Makefile

CC = gcc
CFLAGS = -Wall -Wextra -std=c99 -g
TARGET = myprogram
SOURCES = main.c utils.c
OBJECTS = $(SOURCES:.c=.o)

$(TARGET): $(OBJECTS)
	$(CC) $(OBJECTS) -o $(TARGET)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJECTS) $(TARGET)

.PHONY: clean

CMake

cmake_minimum_required(VERSION 3.10)
project(MyProject C)

set(CMAKE_C_STANDARD 99)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra")

add_executable(myprogram main.c utils.c)

# Link math library
target_link_libraries(myprogram m)

Quick Reference

Format Specifiers

%d // int
%ld // long
%u // unsigned int
%f // float
%lf // double
%c // char
%s // string
%p // pointer
%x // hexadecimal
%o // octal
%zu // size_t

Common Headers

#include <stdio.h> // Input/output
#include <stdlib.h> // Memory management, utilities
#include <string.h> // String functions
#include <math.h> // Mathematical functions
#include <time.h> // Time functions
#include <ctype.h> // Character functions
#include <errno.h> // Error handling
#include <assert.h> // Assertions

Operators

// Arithmetic
+ - * / %

// Comparison
== != < > <= >=

// Logical
&& || !

// Bitwise
& | ^ ~ << >>

// Assignment
= += -= *= /= %=

// Increment/Decrement
++ --

// Member access
. ->

// Ternary
? :

C++

Sun, 01 Jan 2023 00:00:00 +0000

Overview

C++ is a general-purpose programming language that supports procedural, object-oriented, and generic programming. It’s widely used for system programming, game development, embedded systems, and high-performance applications.

Installation

Compilers

# GCC (GNU Compiler Collection)
sudo apt install g++ # Ubuntu/Debian
brew install gcc # macOS
sudo yum install gcc-c++ # CentOS/RHEL

# Clang
sudo apt install clang # Ubuntu/Debian
brew install llvm # macOS

# Microsoft Visual Studio (Windows)
# Download from https://visualstudio.microsoft.com/

Build Tools

# CMake
sudo apt install cmake # Ubuntu/Debian
brew install cmake # macOS

# Make
sudo apt install make # Usually pre-installed

Basic Syntax

Hello World

#include <iostream>

int main() {
 std::cout << "Hello, World!" << std::endl;
 return 0;
}

Compilation

# Basic compilation
g++ -o program program.cpp

# With debugging info
g++ -g -o program program.cpp

# With optimization
g++ -O2 -o program program.cpp

# C++ standard version
g++ -std=c++17 -o program program.cpp

Data Types

Primitive Types

// Integer types
int num = 42;
short s = 10;
long l = 1000000L;
long long ll = 1000000000LL;

// Unsigned types
unsigned int u = 42u;
unsigned long ul = 1000000UL;

// Floating point
float f = 3.14f;
double d = 3.14159;
long double ld = 3.141592653589793L;

// Character types
char c = 'A';
wchar_t wc = L'A';
char16_t c16 = u'A';
char32_t c32 = U'A';

// Boolean
bool flag = true;

// Auto type deduction
auto x = 42; // int
auto y = 3.14; // double
auto z = "hello"; // const char*

Constants

const int MAX_SIZE = 100;
constexpr int SIZE = 10;

// Enumeration
enum Color { RED, GREEN, BLUE };
enum class Status { ACTIVE, INACTIVE, PENDING };

// Using enums
Color c = RED;
Status s = Status::ACTIVE;

Variables and Scope

Variable Declaration

int x; // Declaration
int y = 10; // Initialization
int z{15}; // Uniform initialization
int a(20); // Direct initialization

// Multiple declarations
int m = 1, n = 2, p = 3;

Scope

int global_var = 10; // Global scope

int main() {
 int local_var = 20; // Local scope
 
 {
 int block_var = 30; // Block scope
 // block_var is accessible here
 }
 // block_var is not accessible here
 
 return 0;
}

Functions

Function Declaration

// Function prototype
int add(int a, int b);

// Function definition
int add(int a, int b) {
 return a + b;
}

// Function with default parameters
int multiply(int a, int b = 1) {
 return a * b;
}

// Function overloading
int max(int a, int b) {
 return (a > b) ? a : b;
}

double max(double a, double b) {
 return (a > b) ? a : b;
}

Advanced Functions

// Function templates
template<typename T>
T maximum(T a, T b) {
 return (a > b) ? a : b;
}

// Lambda functions
auto lambda = [](int x, int y) { return x + y; };
int result = lambda(5, 3);

// Lambda with capture
int multiplier = 10;
auto multiply_by = [multiplier](int x) { return x * multiplier; };

Control Structures

Conditionals

// if-else
if (x > 0) {
 std::cout << "Positive" << std::endl;
} else if (x < 0) {
 std::cout << "Negative" << std::endl;
} else {
 std::cout << "Zero" << std::endl;
}

// Ternary operator
int result = (x > 0) ? 1 : -1;

// Switch statement
switch (choice) {
 case 1:
 std::cout << "Option 1" << std::endl;
 break;
 case 2:
 std::cout << "Option 2" << std::endl;
 break;
 default:
 std::cout << "Invalid option" << std::endl;
}

Loops

// for loop
for (int i = 0; i < 10; i++) {
 std::cout << i << " ";
}

// Range-based for loop
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
 std::cout << num << " ";
}

// while loop
int i = 0;
while (i < 10) {
 std::cout << i << " ";
 i++;
}

// do-while loop
int j = 0;
do {
 std::cout << j << " ";
 j++;
} while (j < 10);

Pointers and References

Pointers

int x = 10;
int* ptr = &x; // Pointer to x
int value = *ptr; // Dereference pointer

// Dynamic memory allocation
int* arr = new int[10]; // Allocate array
delete[] arr; // Free memory

int* num = new int(42); // Allocate single int
delete num; // Free memory

References

int x = 10;
int& ref = x; // Reference to x
ref = 20; // Changes x to 20

// Function parameters
void swap(int& a, int& b) {
 int temp = a;
 a = b;
 b = temp;
}

Smart Pointers

#include <memory>

// unique_ptr
std::unique_ptr<int> ptr1 = std::make_unique<int>(42);

// shared_ptr
std::shared_ptr<int> ptr2 = std::make_shared<int>(42);

// weak_ptr
std::weak_ptr<int> weak_ptr = ptr2;

Object-Oriented Programming

Classes and Objects

class Rectangle {
private:
 double width, height;

public:
 // Constructor
 Rectangle(double w, double h) : width(w), height(h) {}
 
 // Default constructor
 Rectangle() : width(0), height(0) {}
 
 // Copy constructor
 Rectangle(const Rectangle& other) 
 : width(other.width), height(other.height) {}
 
 // Destructor
 ~Rectangle() {
 // Cleanup code
 }
 
 // Member functions
 double area() const {
 return width * height;
 }
 
 void setDimensions(double w, double h) {
 width = w;
 height = h;
 }
 
 // Getters
 double getWidth() const { return width; }
 double getHeight() const { return height; }
};

// Usage
Rectangle rect(5.0, 3.0);
double area = rect.area();

Inheritance

// Base class
class Shape {
protected:
 std::string color;
 
public:
 Shape(const std::string& c) : color(c) {}
 
 virtual double area() const = 0; // Pure virtual function
 virtual void draw() const {
 std::cout << "Drawing a " << color << " shape" << std::endl;
 }
 
 virtual ~Shape() = default; // Virtual destructor
};

// Derived class
class Circle : public Shape {
private:
 double radius;
 
public:
 Circle(double r, const std::string& c) : Shape(c), radius(r) {}
 
 double area() const override {
 return 3.14159 * radius * radius;
 }
 
 void draw() const override {
 std::cout << "Drawing a " << color << " circle" << std::endl;
 }
};

Polymorphism

// Virtual functions
class Animal {
public:
 virtual void makeSound() const {
 std::cout << "Some generic animal sound" << std::endl;
 }
 virtual ~Animal() = default;
};

class Dog : public Animal {
public:
 void makeSound() const override {
 std::cout << "Woof!" << std::endl;
 }
};

class Cat : public Animal {
public:
 void makeSound() const override {
 std::cout << "Meow!" << std::endl;
 }
};

// Usage
std::vector<std::unique_ptr<Animal>> animals;
animals.push_back(std::make_unique<Dog>());
animals.push_back(std::make_unique<Cat>());

for (const auto& animal : animals) {
 animal->makeSound(); // Polymorphic call
}

Standard Template Library (STL)

Containers

Vector

#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};
v.push_back(6);
v.pop_back();
int size = v.size();
int element = v[0];

List

#include <list>

std::list<int> l = {1, 2, 3};
l.push_front(0);
l.push_back(4);
l.remove(2);

Map

#include <map>

std::map<std::string, int> m;
m["apple"] = 5;
m["banana"] = 3;
m.insert({"orange", 2});

// Iteration
for (const auto& pair : m) {
 std::cout << pair.first << ": " << pair.second << std::endl;
}

Set

#include <set>

std::set<int> s = {3, 1, 4, 1, 5}; // Automatically sorted, no duplicates
s.insert(2);
s.erase(3);
bool found = s.find(4) != s.end();

Algorithms

#include <algorithm>

std::vector<int> v = {3, 1, 4, 1, 5, 9};

// Sorting
std::sort(v.begin(), v.end());

// Finding
auto it = std::find(v.begin(), v.end(), 4);
if (it != v.end()) {
 std::cout << "Found at position: " << std::distance(v.begin(), it) << std::endl;
}

// Transforming
std::transform(v.begin(), v.end(), v.begin(), [](int x) { return x * 2; });

// Filtering
std::vector<int> filtered;
std::copy_if(v.begin(), v.end(), std::back_inserter(filtered), 
 [](int x) { return x > 5; });

Iterators

std::vector<int> v = {1, 2, 3, 4, 5};

// Forward iterator
for (auto it = v.begin(); it != v.end(); ++it) {
 std::cout << *it << " ";
}

// Reverse iterator
for (auto it = v.rbegin(); it != v.rend(); ++it) {
 std::cout << *it << " ";
}

// Range-based for loop (preferred)
for (int value : v) {
 std::cout << value << " ";
}

Memory Management

Stack vs Heap

// Stack allocation
int x = 10; // Automatically managed
int arr[100]; // Fixed size, stack allocated

// Heap allocation
int* ptr = new int(10); // Manual management required
int* arr = new int[100]; // Dynamic size, heap allocated

// Don't forget to free
delete ptr;
delete[] arr;

RAII (Resource Acquisition Is Initialization)

class FileHandler {
private:
 std::FILE* file;
 
public:
 FileHandler(const std::string& filename) {
 file = std::fopen(filename.c_str(), "r");
 if (!file) {
 throw std::runtime_error("Cannot open file");
 }
 }
 
 ~FileHandler() {
 if (file) {
 std::fclose(file);
 }
 }
 
 // Delete copy constructor and assignment operator
 FileHandler(const FileHandler&) = delete;
 FileHandler& operator=(const FileHandler&) = delete;
};

Exception Handling

Try-Catch

#include <stdexcept>

try {
 int result = divide(10, 0);
 std::cout << "Result: " << result << std::endl;
} catch (const std::runtime_error& e) {
 std::cerr << "Runtime error: " << e.what() << std::endl;
} catch (const std::exception& e) {
 std::cerr << "General error: " << e.what() << std::endl;
} catch (...) {
 std::cerr << "Unknown error occurred" << std::endl;
}

Custom Exceptions

class DivisionByZeroException : public std::exception {
public:
 const char* what() const noexcept override {
 return "Division by zero is not allowed";
 }
};

int divide(int a, int b) {
 if (b == 0) {
 throw DivisionByZeroException();
 }
 return a / b;
}

Templates

Function Templates

template<typename T>
T max(T a, T b) {
 return (a > b) ? a : b;
}

// Usage
int max_int = max(5, 3);
double max_double = max(5.5, 3.3);

Class Templates

template<typename T>
class Stack {
private:
 std::vector<T> elements;
 
public:
 void push(const T& item) {
 elements.push_back(item);
 }
 
 T pop() {
 if (elements.empty()) {
 throw std::runtime_error("Stack is empty");
 }
 T top = elements.back();
 elements.pop_back();
 return top;
 }
 
 bool empty() const {
 return elements.empty();
 }
};

// Usage
Stack<int> int_stack;
Stack<std::string> string_stack;

Template Specialization

template<typename T>
class Container {
public:
 void process() {
 std::cout << "General processing" << std::endl;
 }
};

// Specialization for bool
template<>
class Container<bool> {
public:
 void process() {
 std::cout << "Boolean processing" << std::endl;
 }
};

Modern C++ Features

C++11 Features

// Auto keyword
auto x = 42;
auto y = 3.14;

// Range-based for loop
std::vector<int> v = {1, 2, 3, 4, 5};
for (auto& element : v) {
 element *= 2;
}

// Lambda expressions
auto lambda = [](int x) { return x * 2; };

// nullptr
int* ptr = nullptr; // Instead of NULL

// Move semantics
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1); // v1 is now empty

C++14 Features

// Generic lambda
auto lambda = [](auto x, auto y) { return x + y; };

// Return type deduction
auto fibonacci(int n) {
 if (n <= 1) return n;
 return fibonacci(n-1) + fibonacci(n-2);
}

// Binary literals
int binary = 0b101010;

C++17 Features

// Structured bindings
std::map<std::string, int> m = {{"apple", 5}, {"banana", 3}};
for (const auto& [key, value] : m) {
 std::cout << key << ": " << value << std::endl;
}

// if constexpr
template<typename T>
auto process(T value) {
 if constexpr (std::is_integral_v<T>) {
 return value * 2;
 } else {
 return value;
 }
}

File I/O

Reading Files

#include <fstream>
#include <sstream>

// Read entire file
std::ifstream file("input.txt");
std::string content((std::istreambuf_iterator<char>(file)),
 std::istreambuf_iterator<char>());

// Read line by line
std::ifstream file("input.txt");
std::string line;
while (std::getline(file, line)) {
 std::cout << line << std::endl;
}

Writing Files

#include <fstream>

// Write to file
std::ofstream file("output.txt");
file << "Hello, World!" << std::endl;
file << "Line 2" << std::endl;

// Append to file
std::ofstream file("output.txt", std::ios::app);
file << "Appended line" << std::endl;

Debugging and Best Practices

Debugging

#include <cassert>

// Assertions
assert(x > 0); // Only in debug builds

// Debug output
#ifdef DEBUG
 std::cout << "Debug: x = " << x << std::endl;
#endif

Best Practices

// Use const correctness
void print(const std::string& message) {
 std::cout << message << std::endl;
}

// Use RAII for resource management
class ResourceManager {
 std::unique_ptr<Resource> resource;
public:
 ResourceManager() : resource(std::make_unique<Resource>()) {}
 // Destructor automatically called
};

// Prefer STL containers over raw arrays
std::vector<int> v(100); // Instead of int arr[100];

// Use smart pointers instead of raw pointers
std::unique_ptr<int> ptr = std::make_unique<int>(42);

Common Patterns

Singleton Pattern

class Singleton {
private:
 static Singleton* instance;
 Singleton() = default;
 
public:
 static Singleton* getInstance() {
 if (!instance) {
 instance = new Singleton();
 }
 return instance;
 }
 
 // Delete copy constructor and assignment
 Singleton(const Singleton&) = delete;
 Singleton& operator=(const Singleton&) = delete;
};

Factory Pattern

class Product {
public:
 virtual ~Product() = default;
 virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
 void use() override {
 std::cout << "Using concrete product" << std::endl;
 }
};

class Factory {
public:
 static std::unique_ptr<Product> createProduct() {
 return std::make_unique<ConcreteProduct>();
 }
};

Compilation and Build Systems

CMake

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(MyProject)

set(CMAKE_CXX_STANDARD 17)

add_executable(myapp main.cpp utils.cpp)

# Link libraries
target_link_libraries(myapp pthread)

Makefile

# Makefile
CXX = g++
CXXFLAGS = -std=c++17 -Wall -Wextra -g
TARGET = myapp
SOURCES = main.cpp utils.cpp

$(TARGET): $(SOURCES)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

Performance Tips

Optimization

// Use const references for function parameters
void process(const std::vector<int>& data) {
 // Process data without copying
}

// Use move semantics
std::vector<int> getData() {
 std::vector<int> result(1000);
 // ... fill result
 return result; // Move semantics applied automatically
}

// Reserve vector capacity
std::vector<int> v;
v.reserve(1000); // Avoid reallocations

// Use emplace instead of push
std::vector<std::string> v;
v.emplace_back("Hello"); // Construct in place

Memory Optimization

// Use appropriate data types
std::uint8_t small_number = 255; // Instead of int for small values

// Use object pooling for frequently created objects
class ObjectPool {
 std::vector<std::unique_ptr<Object>> pool;
public:
 std::unique_ptr<Object> acquire() {
 if (pool.empty()) {
 return std::make_unique<Object>();
 }
 auto obj = std::move(pool.back());
 pool.pop_back();
 return obj;
 }
 
 void release(std::unique_ptr<Object> obj) {
 pool.push_back(std::move(obj));
 }
};

Testing

Unit Testing (with Google Test)

#include <gtest/gtest.h>

// Test fixture
class CalculatorTest : public ::testing::Test {
protected:
 void SetUp() override {
 calc = std::make_unique<Calculator>();
 }
 
 std::unique_ptr<Calculator> calc;
};

// Test case
TEST_F(CalculatorTest, Addition) {
 EXPECT_EQ(calc->add(2, 3), 5);
 EXPECT_EQ(calc->add(-1, 1), 0);
}

TEST_F(CalculatorTest, Division) {
 EXPECT_EQ(calc->divide(10, 2), 5);
 EXPECT_THROW(calc->divide(10, 0), std::invalid_argument);
}

Quick Reference

Common Headers

#include <iostream> // Input/output
#include <vector> // Dynamic arrays
#include <string> // String class
#include <algorithm> // Algorithms
#include <memory> // Smart pointers
#include <fstream> // File I/O
#include <map> // Associative containers
#include <thread> // Threading

Essential Operators

// Arithmetic
+ - * / %

// Comparison
== != < > <= >=

// Logical
&& || !

// Bitwise
& | ^ ~ << >>

// Assignment
= += -= *= /= %=

// Increment/Decrement
++ --

// Member access
. ->

// Scope resolution
::

Go

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Go (Golang) is a statically typed, compiled programming language developed at Google. It’s designed for simplicity, efficiency, and excellent concurrency support. Go is widely used for web services, cloud infrastructure, DevOps tools, and system programming.

Installation

Go Installation

# Ubuntu/Debian
sudo apt install golang-go

# macOS
brew install go

# Windows
# Download from https://golang.org/dl/

# Verify installation
go version

# Set GOPATH (optional with Go modules)
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

Module Management

# Initialize new module
go mod init myproject

# Add dependency
go get github.com/gorilla/mux

# Update dependencies
go get -u

# Tidy modules
go mod tidy

# Vendor dependencies
go mod vendor

Basic Syntax

Hello World

package main

import "fmt"

func main() {
 fmt.Println("Hello, World!")
}

Running Go Programs

# Run directly
go run main.go

# Build executable
go build main.go

# Build and install
go install

# Format code
go fmt

# Test code
go test

Data Types

Basic Types

// Integer types
var i int = 42
var i8 int8 = 127
var i16 int16 = 32767
var i32 int32 = 2147483647
var i64 int64 = 9223372036854775807

// Unsigned integers
var u uint = 42
var u8 uint8 = 255
var u16 uint16 = 65535
var u32 uint32 = 4294967295
var u64 uint64 = 18446744073709551615

// Floating point
var f32 float32 = 3.14
var f64 float64 = 3.141592653589793

// Complex numbers
var c64 complex64 = 1 + 2i
var c128 complex128 = 1 + 2i

// Boolean
var b bool = true

// String
var s string = "Hello, Go!"

// Byte (alias for uint8)
var bt byte = 'A'

// Rune (alias for int32, represents Unicode code point)
var r rune = '🚀'

Type Inference

// Short variable declaration
x := 42 // int
y := 3.14 // float64
z := true // bool
s := "hello" // string

// Multiple assignments
a, b := 1, 2
name, age := "John", 30

// Zero values
var i int // 0
var f float64 // 0.0
var b bool // false
var s string // ""
var p *int // nil

Constants

const Pi = 3.14159
const MaxUsers = 1000

// Typed constants
const Name string = "Go"
const Version int = 1

// Constant block
const (
 StatusOK = 200
 StatusNotFound = 404
 StatusError = 500
)

// iota for enumeration
const (
 Sunday = iota // 0
 Monday // 1
 Tuesday // 2
 Wednesday // 3
 Thursday // 4
 Friday // 5
 Saturday // 6
)

Variables and Scope

Variable Declaration

// var declaration
var name string = "John"
var age int = 30

// Multiple variables
var (
 name string = "John"
 age int = 30
 city string = "New York"
)

// Short declaration (inside functions only)
name := "John"
age := 30

// Multiple short declarations
name, age := "John", 30

Scope

package main

import "fmt"

// Package-level variable
var globalVar = "global"

func main() {
 // Function-level variable
 localVar := "local"
 
 {
 // Block-level variable
 blockVar := "block"
 fmt.Println(blockVar)
 }
 // blockVar is not accessible here
 
 fmt.Println(globalVar, localVar)
}

Functions

Function Declaration

// Basic function
func greet(name string) string {
 return "Hello, " + name
}

// Multiple parameters
func add(a, b int) int {
 return a + b
}

// Multiple return values
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, fmt.Errorf("division by zero")
 }
 return a / b, nil
}

// Named return values
func split(sum int) (x, y int) {
 x = sum * 4 / 9
 y = sum - x
 return // naked return
}

Variadic Functions

func sum(numbers ...int) int {
 total := 0
 for _, num := range numbers {
 total += num
 }
 return total
}

// Usage
result := sum(1, 2, 3, 4, 5)
nums := []int{1, 2, 3, 4, 5}
result = sum(nums...) // spread operator

Function Types and Closures

// Function type
type Operation func(int, int) int

// Function as parameter
func calculate(a, b int, op Operation) int {
 return op(a, b)
}

// Anonymous function
multiply := func(x, y int) int {
 return x * y
}

// Closure
func adder() func(int) int {
 sum := 0
 return func(x int) int {
 sum += x
 return sum
 }
}

// Usage
pos, neg := adder(), adder()
fmt.Println(pos(2), neg(-2))

Control Structures

Conditionals

// if statement
if x > 0 {
 fmt.Println("Positive")
} else if x < 0 {
 fmt.Println("Negative")
} else {
 fmt.Println("Zero")
}

// if with initialization
if value := getValue(); value > 0 {
 fmt.Println("Value is positive:", value)
}

// switch statement
switch day := time.Now().Weekday(); {
case day == time.Saturday || day == time.Sunday:
 fmt.Println("Weekend")
default:
 fmt.Println("Weekday")
}

// Type switch
switch v := interface{}(x).(type) {
case int:
 fmt.Printf("Integer: %d\n", v)
case string:
 fmt.Printf("String: %s\n", v)
default:
 fmt.Printf("Unknown type: %T\n", v)
}

Loops

// for loop
for i := 0; i < 10; i++ {
 fmt.Println(i)
}

// while-like loop
i := 0
for i < 10 {
 fmt.Println(i)
 i++
}

// infinite loop
for {
 // loop body
 break // exit condition
}

// range loop
numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
 fmt.Printf("Index: %d, Value: %d\n", index, value)
}

// range with map
m := map[string]int{"a": 1, "b": 2}
for key, value := range m {
 fmt.Printf("Key: %s, Value: %d\n", key, value)
}

// range with channel
ch := make(chan int)
go func() {
 for i := 0; i < 3; i++ {
 ch <- i
 }
 close(ch)
}()

for value := range ch {
 fmt.Println(value)
}

Data Structures

Arrays

// Array declaration
var a [5]int
var b = [5]int{1, 2, 3, 4, 5}
var c = [...]int{1, 2, 3, 4, 5} // compiler counts elements

// Array operations
fmt.Println(len(a)) // length
fmt.Println(a[0]) // access element
a[0] = 10 // modify element

// Multi-dimensional arrays
var matrix [3][3]int
matrix[0][0] = 1

Slices

// Slice declaration
var s []int
s = []int{1, 2, 3, 4, 5}

// Make slice
s = make([]int, 5) // length 5, capacity 5
s = make([]int, 3, 5) // length 3, capacity 5

// Slice operations
s = append(s, 6) // append element
s = append(s, 7, 8) // append multiple
fmt.Println(len(s)) // length
fmt.Println(cap(s)) // capacity

// Slicing
sub := s[1:4] // elements 1, 2, 3
sub = s[:3] // elements 0, 1, 2
sub = s[2:] // from element 2 to end
sub = s[:] // all elements

// Copy slice
dest := make([]int, len(s))
copy(dest, s)

Maps

// Map declaration
var m map[string]int
m = make(map[string]int)

// Map literal
m = map[string]int{
 "apple": 5,
 "banana": 3,
 "orange": 8,
}

// Map operations
m["grape"] = 2 // add/update
delete(m, "banana") // delete
value, ok := m["apple"] // check existence

// Iterate map
for key, value := range m {
 fmt.Printf("%s: %d\n", key, value)
}

Strings

// String operations
s := "Hello, 世界"
fmt.Println(len(s)) // byte length
fmt.Println(len([]rune(s))) // character count

// String manipulation
import "strings"
s = strings.ToUpper(s)
s = strings.ToLower(s)
s = strings.TrimSpace(s)
parts := strings.Split(s, ",")
joined := strings.Join(parts, "-")

// String formatting
import "fmt"
name := "John"
age := 30
message := fmt.Sprintf("Name: %s, Age: %d", name, age)

Structs

Struct Definition

type Person struct {
 Name string
 Age int
 City string
}

// Struct with methods
type Rectangle struct {
 Width float64
 Height float64
}

func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

func (r *Rectangle) Scale(factor float64) {
 r.Width *= factor
 r.Height *= factor
}

Struct Usage

// Create struct
p1 := Person{
 Name: "John",
 Age: 30,
 City: "New York",
}

// Positional initialization
p2 := Person{"Jane", 25, "London"}

// Zero value
var p3 Person

// Pointer to struct
p4 := &Person{
 Name: "Bob",
 Age: 35,
}

// Access fields
fmt.Println(p1.Name)
p1.Age = 31

Embedded Structs

type Address struct {
 Street string
 City string
 State string
}

type Employee struct {
 Name string
 Age int
 Address // embedded struct
}

// Usage
emp := Employee{
 Name: "John",
 Age: 30,
 Address: Address{
 Street: "123 Main St",
 City: "New York",
 State: "NY",
 },
}

// Direct access to embedded fields
fmt.Println(emp.Street) // same as emp.Address.Street

Interfaces

Interface Definition

type Shape interface {
 Area() float64
 Perimeter() float64
}

type Writer interface {
 Write([]byte) (int, error)
}

// Empty interface
var x interface{}
x = 42
x = "hello"
x = []int{1, 2, 3}

Interface Implementation

type Circle struct {
 Radius float64
}

func (c Circle) Area() float64 {
 return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
 return 2 * math.Pi * c.Radius
}

// Usage
var s Shape = Circle{Radius: 5}
fmt.Println(s.Area())

Type Assertions

var i interface{} = "hello"

// Type assertion
s := i.(string)
fmt.Println(s)

// Safe type assertion
s, ok := i.(string)
if ok {
 fmt.Println(s)
}

// Type switch
switch v := i.(type) {
case int:
 fmt.Printf("Integer: %d\n", v)
case string:
 fmt.Printf("String: %s\n", v)
default:
 fmt.Printf("Unknown type: %T\n", v)
}

Error Handling

Error Type

// Error interface
type error interface {
 Error() string
}

// Creating errors
import "errors"
err := errors.New("something went wrong")

// Formatted errors
import "fmt"
err := fmt.Errorf("failed to process %s: %w", filename, originalErr)

Error Handling Patterns

// Basic error handling
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("division by zero")
 }
 return a / b, nil
}

// Usage
result, err := divide(10, 2)
if err != nil {
 log.Fatal(err)
}
fmt.Println(result)

// Multiple error checks
func processFile(filename string) error {
 file, err := os.Open(filename)
 if err != nil {
 return fmt.Errorf("failed to open file: %w", err)
 }
 defer file.Close()
 
 data, err := io.ReadAll(file)
 if err != nil {
 return fmt.Errorf("failed to read file: %w", err)
 }
 
 // Process data
 return nil
}

Custom Errors

type ValidationError struct {
 Field string
 Value interface{}
 Msg string
}

func (e *ValidationError) Error() string {
 return fmt.Sprintf("validation failed for field %s: %s", e.Field, e.Msg)
}

// Usage
func validateAge(age int) error {
 if age < 0 {
 return &ValidationError{
 Field: "age",
 Value: age,
 Msg: "age cannot be negative",
 }
 }
 return nil
}

Concurrency

Goroutines

// Start goroutine
go func() {
 fmt.Println("Hello from goroutine")
}()

// Goroutine with parameters
go func(msg string) {
 fmt.Println(msg)
}("Hello, concurrent world!")

// Wait for goroutines
import "sync"
var wg sync.WaitGroup

for i := 0; i < 5; i++ {
 wg.Add(1)
 go func(n int) {
 defer wg.Done()
 fmt.Printf("Goroutine %d\n", n)
 }(i)
}
wg.Wait()

Channels

// Create channel
ch := make(chan int)

// Buffered channel
ch := make(chan int, 10)

// Send and receive
go func() {
 ch <- 42 // send
}()
value := <-ch // receive

// Channel directions
func sender(ch chan<- int) {
 ch <- 42
}

func receiver(ch <-chan int) {
 value := <-ch
 fmt.Println(value)
}

// Close channel
close(ch)

// Range over channel
for value := range ch {
 fmt.Println(value)
}

Select Statement

select {
case msg1 := <-ch1:
 fmt.Println("Received from ch1:", msg1)
case msg2 := <-ch2:
 fmt.Println("Received from ch2:", msg2)
case <-time.After(1 * time.Second):
 fmt.Println("Timeout")
default:
 fmt.Println("No channel ready")
}

Sync Package

import "sync"

// Mutex
var mu sync.Mutex
mu.Lock()
// critical section
mu.Unlock()

// RWMutex
var rwmu sync.RWMutex
rwmu.RLock()
// read operation
rwmu.RUnlock()

rwmu.Lock()
// write operation
rwmu.Unlock()

// Once
var once sync.Once
once.Do(func() {
 fmt.Println("This runs only once")
})

Standard Library

Package Management

// Import packages
import "fmt"
import "net/http"

// Multiple imports
import (
 "fmt"
 "net/http"
 "time"
)

// Package alias
import (
 f "fmt"
 h "net/http"
)

// Blank import
import _ "database/sql"

Common Packages

// fmt - Formatted I/O
import "fmt"
fmt.Println("Hello")
fmt.Printf("Value: %d\n", 42)
fmt.Sprintf("Formatted: %s", "string")

// strings - String manipulation
import "strings"
strings.Contains("hello", "ell")
strings.Split("a,b,c", ",")
strings.Join([]string{"a", "b"}, "-")

// strconv - String conversions
import "strconv"
i, err := strconv.Atoi("42")
s := strconv.Itoa(42)
f, err := strconv.ParseFloat("3.14", 64)

// time - Time operations
import "time"
now := time.Now()
duration := time.Duration(5) * time.Second
time.Sleep(duration)

File Operations

import (
 "os"
 "io"
 "bufio"
)

// Read file
data, err := os.ReadFile("filename.txt")
if err != nil {
 log.Fatal(err)
}

// Write file
err = os.WriteFile("output.txt", []byte("Hello, World!"), 0644)
if err != nil {
 log.Fatal(err)
}

// Open file
file, err := os.Open("filename.txt")
if err != nil {
 log.Fatal(err)
}
defer file.Close()

// Buffered reading
scanner := bufio.NewScanner(file)
for scanner.Scan() {
 fmt.Println(scanner.Text())
}

HTTP Client/Server

import (
 "net/http"
 "encoding/json"
)

// HTTP client
resp, err := http.Get("https://api.example.com/users")
if err != nil {
 log.Fatal(err)
}
defer resp.Body.Close()

body, err := io.ReadAll(resp.Body)
if err != nil {
 log.Fatal(err)
}

// HTTP server
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "Hello, World!")
})

http.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
 users := []string{"Alice", "Bob", "Charlie"}
 json.NewEncoder(w).Encode(users)
})

log.Fatal(http.ListenAndServe(":8080", nil))

JSON Processing

import "encoding/json"

// Struct for JSON
type User struct {
 Name string `json:"name"`
 Email string `json:"email"`
 Age int `json:"age"`
}

// Marshal to JSON
user := User{Name: "John", Email: "john@example.com", Age: 30}
data, err := json.Marshal(user)
if err != nil {
 log.Fatal(err)
}

// Unmarshal from JSON
var user2 User
err = json.Unmarshal(data, &user2)
if err != nil {
 log.Fatal(err)
}

// Working with generic JSON
var result map[string]interface{}
err = json.Unmarshal(data, &result)

Testing

Basic Testing

// math.go
package math

func Add(a, b int) int {
 return a + b
}

// math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
 result := Add(2, 3)
 expected := 5
 if result != expected {
 t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
 }
}

func TestAddMultiple(t *testing.T) {
 tests := []struct {
 a, b, expected int
 }{
 {2, 3, 5},
 {-1, 1, 0},
 {0, 0, 0},
 }
 
 for _, test := range tests {
 result := Add(test.a, test.b)
 if result != test.expected {
 t.Errorf("Add(%d, %d) = %d; expected %d", 
 test.a, test.b, result, test.expected)
 }
 }
}

Benchmarking

func BenchmarkAdd(b *testing.B) {
 for i := 0; i < b.N; i++ {
 Add(2, 3)
 }
}

// Run benchmarks
// go test -bench=.

Test Coverage

# Run tests with coverage
go test -cover

# Generate coverage report
go test -coverprofile=coverage.out
go tool cover -html=coverage.out

Best Practices

Code Organization

// Package declaration
package main

// Import block
import (
 "fmt"
 "net/http"
 
 "github.com/gorilla/mux"
)

// Constants
const (
 DefaultPort = 8080
 MaxRetries = 3
)

// Types
type Server struct {
 port int
 mux *mux.Router
}

// Functions
func NewServer(port int) *Server {
 return &Server{
 port: port,
 mux: mux.NewRouter(),
 }
}

Error Handling

// Don't ignore errors
result, err := someFunction()
if err != nil {
 return fmt.Errorf("failed to process: %w", err)
}

// Use early returns
func processUser(user User) error {
 if user.Name == "" {
 return errors.New("name is required")
 }
 
 if user.Email == "" {
 return errors.New("email is required")
 }
 
 // Process user
 return nil
}

Resource Management

// Always close resources
file, err := os.Open("filename.txt")
if err != nil {
 return err
}
defer file.Close()

// Use context for cancellation
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com", nil)

Performance Tips

Memory Management

// Use slices efficiently
s := make([]int, 0, 100) // preallocate capacity
s = append(s, 1, 2, 3)

// Avoid memory leaks with slices
func processLargeSlice(data []int) []int {
 // Process only first 10 elements
 result := make([]int, 10)
 copy(result, data[:10])
 return result // Don't return data[:10] to avoid holding large slice
}

// Use string builder for concatenation
var builder strings.Builder
for i := 0; i < 1000; i++ {
 builder.WriteString("item")
}
result := builder.String()

Concurrency Patterns

// Worker pool pattern
func workerPool(jobs <-chan int, results chan<- int) {
 for job := range jobs {
 // Process job
 results <- job * 2
 }
}

// Start workers
jobs := make(chan int, 100)
results := make(chan int, 100)

for w := 1; w <= 3; w++ {
 go workerPool(jobs, results)
}

// Fan-out pattern
func fanOut(input <-chan int, workers int) []<-chan int {
 outputs := make([]<-chan int, workers)
 for i := 0; i < workers; i++ {
 output := make(chan int)
 outputs[i] = output
 go func() {
 for n := range input {
 output <- n * 2
 }
 close(output)
 }()
 }
 return outputs
}

Common Patterns

Singleton Pattern

type singleton struct {
 data string
}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
 once.Do(func() {
 instance = &singleton{data: "singleton"}
 })
 return instance
}

Factory Pattern

type Shape interface {
 Draw()
}

type Circle struct{}
func (c Circle) Draw() { fmt.Println("Drawing circle") }

type Rectangle struct{}
func (r Rectangle) Draw() { fmt.Println("Drawing rectangle") }

func CreateShape(shapeType string) Shape {
 switch shapeType {
 case "circle":
 return Circle{}
 case "rectangle":
 return Rectangle{}
 default:
 return nil
 }
}

Observer Pattern

type Observer interface {
 Update(string)
}

type Subject struct {
 observers []Observer
}

func (s *Subject) Attach(o Observer) {
 s.observers = append(s.observers, o)
}

func (s *Subject) Notify(message string) {
 for _, observer := range s.observers {
 observer.Update(message)
 }
}

Build and Deployment

Build Options

# Build for current platform
go build

# Build for specific platform
GOOS=linux GOARCH=amd64 go build

# Build with optimizations
go build -ldflags="-s -w"

# Build with version info
go build -ldflags="-X main.version=1.0.0"

Modules

# Initialize module
go mod init myproject

# Add dependency
go get github.com/gorilla/mux@v1.8.0

# Update dependencies
go get -u

# Remove unused dependencies
go mod tidy

# Create vendor directory
go mod vendor

Quick Reference

Basic Syntax

// Variable declaration
var name string = "value"
name := "value"

// Function declaration
func name(params) returnType {
 return value
}

// Struct declaration
type Name struct {
 field type
}

// Interface declaration
type Name interface {
 Method() returnType
}

Common Operations

// Slices
append(slice, element)
copy(dest, src)
len(slice)
cap(slice)

// Maps
make(map[keyType]valueType)
delete(map, key)
value, ok := map[key]

// Channels
make(chan type)
make(chan type, capacity)
close(channel)
<-channel // receive
channel <- value // send

Error Handling

if err != nil {
 return err
}

// Wrap error
return fmt.Errorf("operation failed: %w", err)

Concurrency

// Goroutine
go func() {
 // concurrent code
}()

// Channel
ch := make(chan int)
go func() { ch <- 42 }()
value := <-ch

// Select
select {
case <-ch1:
 // handle ch1
case <-ch2:
 // handle ch2
default:
 // no channel ready
}

Java

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Java is a high-level, object-oriented programming language designed for platform independence. It’s widely used for enterprise applications, Android development, web services, and large-scale systems.

Installation

Java Development Kit (JDK)

# Ubuntu/Debian
sudo apt install openjdk-11-jdk

# macOS
brew install openjdk@11

# Windows
# Download from https://adoptium.net/

# Verify installation
java -version
javac -version

Build Tools

# Maven
sudo apt install maven
mvn --version

# Gradle
sudo apt install gradle
gradle --version

Basic Syntax

Hello World

public class HelloWorld {
 public static void main(String[] args) {
 System.out.println("Hello, World!");
 }
}

Compilation and Execution

# Compile
javac HelloWorld.java

# Run
java HelloWorld

# Run with classpath
java -cp . HelloWorld

Data Types

Primitive Types

// Integer types
byte b = 127; // 8-bit signed (-128 to 127)
short s = 32767; // 16-bit signed
int i = 2147483647; // 32-bit signed
long l = 9223372036854775807L; // 64-bit signed

// Floating point
float f = 3.14f; // 32-bit IEEE 754
double d = 3.14159265359; // 64-bit IEEE 754

// Character and boolean
char c = 'A'; // 16-bit Unicode
boolean flag = true; // true or false

Reference Types

// Strings
String name = "John";
String message = new String("Hello");

// Arrays
int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[10];

// Object references
Object obj = new Object();
String str = null; // null reference

Type Conversion

// Implicit conversion (widening)
int i = 42;
double d = i; // int to double

// Explicit conversion (narrowing)
double d = 3.14;
int i = (int) d; // double to int

// String conversion
String str = String.valueOf(42);
int num = Integer.parseInt("123");
double value = Double.parseDouble("3.14");

Variables and Constants

Variable Declaration

// Declaration and initialization
int number = 42;
String name = "Alice";

// Multiple declarations
int x = 10, y = 20, z = 30;

// Final variables (constants)
final int MAX_SIZE = 100;
final double PI = 3.14159;

// Static variables
static int counter = 0;

Variable Scope

public class ScopeExample {
 // Instance variable
 private int instanceVar = 10;
 
 // Class variable
 static int classVar = 20;
 
 public void method() {
 // Local variable
 int localVar = 30;
 
 // Block scope
 {
 int blockVar = 40;
 // blockVar is accessible here
 }
 // blockVar is not accessible here
 }
}

Operators

Arithmetic Operators

int a = 10, b = 3;
int sum = a + b; // Addition: 13
int diff = a - b; // Subtraction: 7
int product = a * b; // Multiplication: 30
int quotient = a / b; // Division: 3
int remainder = a % b; // Modulus: 1

// Unary operators
int x = 5;
int y = ++x; // Pre-increment: x=6, y=6
int z = x++; // Post-increment: x=7, z=6

Comparison and Logical Operators

int a = 10, b = 20;
boolean result;

// Comparison
result = a == b; // Equal to: false
result = a != b; // Not equal to: true
result = a < b; // Less than: true
result = a > b; // Greater than: false
result = a <= b; // Less than or equal: true
result = a >= b; // Greater than or equal: false

// Logical
result = true && false; // AND: false
result = true || false; // OR: true
result = !true; // NOT: false

Bitwise Operators

int a = 5; // 101 in binary
int b = 3; // 011 in binary

int and = a & b; // AND: 001 = 1
int or = a | b; // OR: 111 = 7
int xor = a ^ b; // XOR: 110 = 6
int not = ~a; // NOT: ...11111010 = -6
int left = a << 1; // Left shift: 1010 = 10
int right = a >> 1; // Right shift: 10 = 2

Control Structures

Conditionals

// if-else
int x = 10;
if (x > 0) {
 System.out.println("Positive");
} else if (x < 0) {
 System.out.println("Negative");
} else {
 System.out.println("Zero");
}

// Ternary operator
String result = (x > 0) ? "positive" : "not positive";

// Switch statement
int day = 2;
switch (day) {
 case 1:
 System.out.println("Monday");
 break;
 case 2:
 System.out.println("Tuesday");
 break;
 default:
 System.out.println("Other day");
}

// Switch expression (Java 14+)
String dayName = switch (day) {
 case 1 -> "Monday";
 case 2 -> "Tuesday";
 case 3 -> "Wednesday";
 default -> "Other day";
};

Loops

// for loop
for (int i = 0; i < 10; i++) {
 System.out.println(i);
}

// Enhanced for loop (for-each)
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
 System.out.println(num);
}

// while loop
int i = 0;
while (i < 10) {
 System.out.println(i);
 i++;
}

// do-while loop
int j = 0;
do {
 System.out.println(j);
 j++;
} while (j < 10);

// Loop control
for (int i = 0; i < 10; i++) {
 if (i == 5) continue; // Skip iteration
 if (i == 8) break; // Exit loop
 System.out.println(i);
}

Methods

Method Declaration

public class Calculator {
 // Method with return value
 public int add(int a, int b) {
 return a + b;
 }
 
 // Method without return value
 public void printMessage(String message) {
 System.out.println(message);
 }
 
 // Method with variable arguments
 public int sum(int... numbers) {
 int total = 0;
 for (int num : numbers) {
 total += num;
 }
 return total;
 }
 
 // Static method
 public static double calculateArea(double radius) {
 return Math.PI * radius * radius;
 }
}

Method Overloading

public class MathUtils {
 public int max(int a, int b) {
 return (a > b) ? a : b;
 }
 
 public double max(double a, double b) {
 return (a > b) ? a : b;
 }
 
 public int max(int a, int b, int c) {
 return max(max(a, b), c);
 }
}

Object-Oriented Programming

Classes and Objects

public class Person {
 // Fields (instance variables)
 private String name;
 private int age;
 
 // Constructor
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
 }
 
 // Default constructor
 public Person() {
 this("Unknown", 0);
 }
 
 // Getter methods
 public String getName() {
 return name;
 }
 
 public int getAge() {
 return age;
 }
 
 // Setter methods
 public void setName(String name) {
 this.name = name;
 }
 
 public void setAge(int age) {
 if (age >= 0) {
 this.age = age;
 }
 }
 
 // toString method
 @Override
 public String toString() {
 return "Person{name='" + name + "', age=" + age + "}";
 }
}

// Usage
Person person = new Person("Alice", 30);
System.out.println(person.getName());
System.out.println(person);

Inheritance

// Base class
public class Animal {
 protected String name;
 
 public Animal(String name) {
 this.name = name;
 }
 
 public void makeSound() {
 System.out.println("Some generic sound");
 }
 
 public void info() {
 System.out.println("I am " + name);
 }
}

// Derived class
public class Dog extends Animal {
 private String breed;
 
 public Dog(String name, String breed) {
 super(name); // Call parent constructor
 this.breed = breed;
 }
 
 @Override
 public void makeSound() {
 System.out.println("Woof!");
 }
 
 @Override
 public void info() {
 super.info(); // Call parent method
 System.out.println("I am a " + breed);
 }
}

Polymorphism

// Using inheritance polymorphism
Animal[] animals = {
 new Dog("Buddy", "Golden Retriever"),
 new Cat("Whiskers", "Persian"),
 new Animal("Generic")
};

for (Animal animal : animals) {
 animal.makeSound(); // Polymorphic call
}

// Interface polymorphism
interface Drawable {
 void draw();
}

class Circle implements Drawable {
 public void draw() {
 System.out.println("Drawing a circle");
 }
}

class Rectangle implements Drawable {
 public void draw() {
 System.out.println("Drawing a rectangle");
 }
}

Abstract Classes and Interfaces

// Abstract class
public abstract class Shape {
 protected String color;
 
 public Shape(String color) {
 this.color = color;
 }
 
 // Abstract method
 public abstract double getArea();
 
 // Concrete method
 public void displayColor() {
 System.out.println("Color: " + color);
 }
}

// Interface
public interface Drawable {
 void draw();
 
 // Default method (Java 8+)
 default void highlight() {
 System.out.println("Highlighting shape");
 }
 
 // Static method (Java 8+)
 static void printInfo() {
 System.out.println("This is a drawable shape");
 }
}

// Implementation
public class Circle extends Shape implements Drawable {
 private double radius;
 
 public Circle(String color, double radius) {
 super(color);
 this.radius = radius;
 }
 
 @Override
 public double getArea() {
 return Math.PI * radius * radius;
 }
 
 @Override
 public void draw() {
 System.out.println("Drawing a circle");
 }
}

Arrays

Array Declaration and Initialization

// Declaration
int[] numbers;
String[] names;

// Initialization
numbers = new int[5]; // Array of 5 integers
names = new String[3]; // Array of 3 strings

// Declaration and initialization
int[] values = {1, 2, 3, 4, 5};
String[] colors = {"red", "green", "blue"};
int[] data = new int[]{10, 20, 30};

// Array properties
int length = numbers.length; // Array length

Array Operations

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

// Access elements
int first = numbers[0];
int last = numbers[numbers.length - 1];

// Modify elements
numbers[0] = 10;

// Iterate through array
for (int i = 0; i < numbers.length; i++) {
 System.out.println(numbers[i]);
}

// Enhanced for loop
for (int num : numbers) {
 System.out.println(num);
}

// Array utilities
import java.util.Arrays;
Arrays.sort(numbers); // Sort array
String str = Arrays.toString(numbers); // Convert to string
int[] copy = Arrays.copyOf(numbers, numbers.length); // Copy array

Multi-dimensional Arrays

// 2D array
int[][] matrix = new int[3][3];
int[][] values = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// Access elements
int element = matrix[1][2];

// Iterate through 2D array
for (int i = 0; i < matrix.length; i++) {
 for (int j = 0; j < matrix[i].length; j++) {
 System.out.print(matrix[i][j] + " ");
 }
 System.out.println();
}

// Enhanced for loop for 2D array
for (int[] row : matrix) {
 for (int element : row) {
 System.out.print(element + " ");
 }
 System.out.println();
}

Strings

String Operations

String str = "Hello, World!";

// String methods
int length = str.length();
char ch = str.charAt(0);
String upper = str.toUpperCase();
String lower = str.toLowerCase();
String trimmed = str.trim();
String replaced = str.replace("World", "Java");
String[] parts = str.split(",");
boolean starts = str.startsWith("Hello");
boolean ends = str.endsWith("!");
int index = str.indexOf("World");
String substring = str.substring(0, 5);

String Comparison

String str1 = "Hello";
String str2 = "Hello";
String str3 = new String("Hello");

// Reference comparison
boolean same = (str1 == str2); // true (string pool)
boolean different = (str1 == str3); // false (different objects)

// Content comparison
boolean equal = str1.equals(str2); // true
boolean equalIgnoreCase = str1.equalsIgnoreCase("HELLO"); // true
int comparison = str1.compareTo(str2); // 0 (equal)

String Building

// StringBuilder (mutable)
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();

// StringBuffer (thread-safe)
StringBuffer buffer = new StringBuffer();
buffer.append("Thread-safe");
buffer.append(" string building");

// String formatting
String formatted = String.format("Name: %s, Age: %d", "Alice", 30);

Collections Framework

List Interface

import java.util.*;

// ArrayList
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

// LinkedList
List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);

// List operations
String first = list.get(0);
list.set(0, "Apricot");
list.remove(1);
boolean contains = list.contains("Cherry");
int size = list.size();

// Iteration
for (String item : list) {
 System.out.println(item);
}

// Lambda expression (Java 8+)
list.forEach(System.out::println);

Set Interface

// HashSet
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple"); // Duplicate, won't be added

// TreeSet (sorted)
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2); // Will be stored as [1, 2, 3]

// Set operations
boolean added = set.add("Cherry");
boolean removed = set.remove("Banana");
boolean contains = set.contains("Apple");

Map Interface

// HashMap
Map<String, Integer> map = new HashMap<>();
map.put("apple", 5);
map.put("banana", 3);
map.put("cherry", 8);

// TreeMap (sorted by keys)
Map<String, Integer> treeMap = new TreeMap<>();

// Map operations
Integer value = map.get("apple");
Integer defaultValue = map.getOrDefault("grape", 0);
boolean containsKey = map.containsKey("banana");
boolean containsValue = map.containsValue(5);
map.remove("cherry");

// Iteration
for (Map.Entry<String, Integer> entry : map.entrySet()) {
 System.out.println(entry.getKey() + ": " + entry.getValue());
}

// Lambda iteration (Java 8+)
map.forEach((key, value) -> System.out.println(key + ": " + value));

Queue Interface

// LinkedList as Queue
Queue<String> queue = new LinkedList<>();
queue.offer("First");
queue.offer("Second");
queue.offer("Third");

String head = queue.poll(); // Remove and return head
String peek = queue.peek(); // Return head without removing

// PriorityQueue
Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(3);
priorityQueue.offer(1);
priorityQueue.offer(2);
// Elements will be retrieved in sorted order

Exception Handling

Try-Catch-Finally

try {
 int result = 10 / 0;
 System.out.println(result);
} catch (ArithmeticException e) {
 System.out.println("Division by zero: " + e.getMessage());
} catch (Exception e) {
 System.out.println("General exception: " + e.getMessage());
} finally {
 System.out.println("This always executes");
}

Custom Exceptions

public class CustomException extends Exception {
 public CustomException(String message) {
 super(message);
 }
}

public class ValidationException extends RuntimeException {
 public ValidationException(String message) {
 super(message);
 }
}

// Usage
public void validateAge(int age) throws CustomException {
 if (age < 0) {
 throw new CustomException("Age cannot be negative");
 }
 if (age > 150) {
 throw new CustomException("Age seems unrealistic");
 }
}

Try-with-Resources

import java.io.*;

// Automatic resource management
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
 String line;
 while ((line = reader.readLine()) != null) {
 System.out.println(line);
 }
} catch (IOException e) {
 e.printStackTrace();
}
// reader is automatically closed

File I/O

File Operations

import java.io.*;
import java.nio.file.*;

// Reading files
try {
 // Read entire file
 String content = new String(Files.readAllBytes(Paths.get("file.txt")));
 
 // Read lines
 List<String> lines = Files.readAllLines(Paths.get("file.txt"));
 
 // Read with BufferedReader
 try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
 String line;
 while ((line = reader.readLine()) != null) {
 System.out.println(line);
 }
 }
} catch (IOException e) {
 e.printStackTrace();
}

Writing Files

import java.io.*;
import java.nio.file.*;

// Writing files
try {
 // Write string to file
 Files.write(Paths.get("output.txt"), "Hello, World!".getBytes());
 
 // Write lines to file
 List<String> lines = Arrays.asList("Line 1", "Line 2", "Line 3");
 Files.write(Paths.get("output.txt"), lines);
 
 // Write with BufferedWriter
 try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("output.txt"))) {
 writer.write("Hello, World!");
 writer.newLine();
 writer.write("Second line");
 }
} catch (IOException e) {
 e.printStackTrace();
}

Generics

Generic Classes

public class Box<T> {
 private T content;
 
 public void set(T content) {
 this.content = content;
 }
 
 public T get() {
 return content;
 }
}

// Usage
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get();

Box<Integer> intBox = new Box<>();
intBox.set(42);
Integer number = intBox.get();

Generic Methods

public class Utility {
 public static <T> void swap(T[] array, int i, int j) {
 T temp = array[i];
 array[i] = array[j];
 array[j] = temp;
 }
 
 public static <T extends Comparable<T>> T max(T a, T b) {
 return (a.compareTo(b) > 0) ? a : b;
 }
}

// Usage
String[] strings = {"apple", "banana", "cherry"};
Utility.swap(strings, 0, 2);

String max = Utility.max("apple", "banana");

Wildcards

// Upper bounded wildcard
List<? extends Number> numbers = new ArrayList<Integer>();

// Lower bounded wildcard
List<? super Integer> integers = new ArrayList<Number>();

// Unbounded wildcard
List<?> objects = new ArrayList<String>();

// Generic method with wildcards
public static void printList(List<?> list) {
 for (Object item : list) {
 System.out.println(item);
 }
}

Lambda Expressions and Streams

Lambda Expressions

// Traditional anonymous class
Runnable r1 = new Runnable() {
 @Override
 public void run() {
 System.out.println("Hello");
 }
};

// Lambda expression
Runnable r2 = () -> System.out.println("Hello");

// Lambda with parameters
Comparator<String> comp = (s1, s2) -> s1.compareTo(s2);

// Method reference
Comparator<String> comp2 = String::compareTo;

Streams

import java.util.stream.*;

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filter and collect
List<Integer> evens = numbers.stream()
 .filter(n -> n % 2 == 0)
 .collect(Collectors.toList());

// Map and reduce
int sum = numbers.stream()
 .mapToInt(Integer::intValue)
 .sum();

// Complex operations
List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> result = words.stream()
 .filter(word -> word.length() > 5)
 .map(String::toUpperCase)
 .sorted()
 .collect(Collectors.toList());

// Parallel streams
long count = numbers.parallelStream()
 .filter(n -> n > 5)
 .count();

Multithreading

Thread Creation

// Extending Thread class
class MyThread extends Thread {
 @Override
 public void run() {
 System.out.println("Thread running: " + getName());
 }
}

// Implementing Runnable interface
class MyRunnable implements Runnable {
 @Override
 public void run() {
 System.out.println("Runnable running: " + Thread.currentThread().getName());
 }
}

// Usage
Thread thread1 = new MyThread();
Thread thread2 = new Thread(new MyRunnable());
Thread thread3 = new Thread(() -> System.out.println("Lambda thread"));

thread1.start();
thread2.start();
thread3.start();

Thread Synchronization

public class Counter {
 private int count = 0;
 
 // Synchronized method
 public synchronized void increment() {
 count++;
 }
 
 // Synchronized block
 public void increment2() {
 synchronized (this) {
 count++;
 }
 }
 
 public int getCount() {
 return count;
 }
}

// Using locks
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockCounter {
 private int count = 0;
 private final Lock lock = new ReentrantLock();
 
 public void increment() {
 lock.lock();
 try {
 count++;
 } finally {
 lock.unlock();
 }
 }
}

Executor Framework

import java.util.concurrent.*;

// Create thread pool
ExecutorService executor = Executors.newFixedThreadPool(5);

// Submit tasks
Future<String> future = executor.submit(() -> {
 Thread.sleep(1000);
 return "Task completed";
});

// Get result
try {
 String result = future.get();
 System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
 e.printStackTrace();
}

// Shutdown executor
executor.shutdown();

Package and Module System

Package Declaration

// File: com/example/util/StringUtils.java
package com.example.util;

public class StringUtils {
 public static String reverse(String str) {
 return new StringBuilder(str).reverse().toString();
 }
}

Import Statements

// Specific import
import com.example.util.StringUtils;

// Wildcard import
import java.util.*;

// Static import
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

// Usage
double area = PI * sqrt(25);

Module System (Java 9+)

// module-info.java
module com.example.app {
 requires java.base;
 requires java.logging;
 exports com.example.app.api;
 opens com.example.app.model to gson;
}

Best Practices

Code Organization

// Good class structure
public class Employee {
 // Constants
 private static final String COMPANY_NAME = "TechCorp";
 
 // Class variables
 private static int employeeCount = 0;
 
 // Instance variables
 private String name;
 private int id;
 private double salary;
 
 // Constructor
 public Employee(String name, int id, double salary) {
 this.name = name;
 this.id = id;
 this.salary = salary;
 employeeCount++;
 }
 
 // Getters and setters
 public String getName() { return name; }
 public void setName(String name) { this.name = name; }
 
 // Business methods
 public void work() {
 System.out.println(name + " is working");
 }
 
 // Static methods
 public static int getEmployeeCount() {
 return employeeCount;
 }
 
 // Override methods
 @Override
 public String toString() {
 return String.format("Employee{name='%s', id=%d, salary=%.2f}", 
 name, id, salary);
 }
}

Documentation

/**
 * Represents a geometric circle with radius and center point.
 * 
 * @author John Doe
 * @version 1.0
 * @since 2024-01-01
 */
public class Circle {
 private double radius;
 
 /**
 * Creates a new circle with the specified radius.
 * 
 * @param radius the radius of the circle
 * @throws IllegalArgumentException if radius is negative
 */
 public Circle(double radius) {
 if (radius < 0) {
 throw new IllegalArgumentException("Radius cannot be negative");
 }
 this.radius = radius;
 }
 
 /**
 * Calculates and returns the area of the circle.
 * 
 * @return the area of the circle
 */
 public double getArea() {
 return Math.PI * radius * radius;
 }
}

Build Tools

Maven

<!-- pom.xml -->
<project>
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.example</groupId>
 <artifactId>my-app</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>jar</packaging>
 
 <properties>
 <maven.compiler.source>11</maven.compiler.source>
 <maven.compiler.target>11</maven.compiler.target>
 </properties>
 
 <dependencies>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.13.2</version>
 <scope>test</scope>
 </dependency>
 </dependencies>
</project>

Gradle

// build.gradle
plugins {
 id 'java'
 id 'application'
}

java {
 sourceCompatibility = JavaVersion.VERSION_11
 targetCompatibility = JavaVersion.VERSION_11
}

repositories {
 mavenCentral()
}

dependencies {
 testImplementation 'junit:junit:4.13.2'
 implementation 'com.google.gson:gson:2.8.9'
}

application {
 mainClass = 'com.example.Main'
}

Testing

JUnit

import org.junit.*;
import static org.junit.Assert.*;

public class CalculatorTest {
 private Calculator calculator;
 
 @Before
 public void setUp() {
 calculator = new Calculator();
 }
 
 @Test
 public void testAdd() {
 assertEquals(5, calculator.add(2, 3));
 assertEquals(0, calculator.add(-1, 1));
 }
 
 @Test(expected = IllegalArgumentException.class)
 public void testDivideByZero() {
 calculator.divide(10, 0);
 }
 
 @Test
 public void testMultiply() {
 assertEquals(6, calculator.multiply(2, 3));
 assertEquals(0, calculator.multiply(0, 5));
 }
 
 @After
 public void tearDown() {
 calculator = null;
 }
}

JUnit 5

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {
 private Calculator calculator;
 
 @BeforeEach
 void setUp() {
 calculator = new Calculator();
 }
 
 @Test
 void testAdd() {
 assertEquals(5, calculator.add(2, 3));
 assertEquals(0, calculator.add(-1, 1));
 }
 
 @Test
 void testDivideByZero() {
 assertThrows(IllegalArgumentException.class, () -> {
 calculator.divide(10, 0);
 });
 }
 
 @ParameterizedTest
 @ValueSource(ints = {1, 2, 3, 4, 5})
 void testIsPositive(int number) {
 assertTrue(calculator.isPositive(number));
 }
}

Performance and Memory

Memory Management

// Weak references
import java.lang.ref.WeakReference;

WeakReference<Object> weakRef = new WeakReference<>(new Object());
Object obj = weakRef.get(); // May return null if GC collected

// String intern
String str1 = new String("Hello").intern();
String str2 = "Hello";
boolean same = (str1 == str2); // true

// Object pooling
public class ObjectPool<T> {
 private final Queue<T> pool = new ConcurrentLinkedQueue<>();
 private final Supplier<T> factory;
 
 public ObjectPool(Supplier<T> factory) {
 this.factory = factory;
 }
 
 public T acquire() {
 T object = pool.poll();
 return (object != null) ? object : factory.get();
 }
 
 public void release(T object) {
 pool.offer(object);
 }
}

Performance Tips

// Use StringBuilder for string concatenation
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
 sb.append("Item ").append(i).append("\n");
}
String result = sb.toString();

// Use appropriate collection types
List<String> list = new ArrayList<>(); // Random access
List<String> linkedList = new LinkedList<>(); // Frequent insertions/deletions

// Use primitive collections when possible
import java.util.stream.IntStream;
IntStream.range(0, 1000).sum(); // Primitive stream

Quick Reference

Common Classes

// Object class methods
equals(Object obj)
hashCode()
toString()
getClass()
clone()

// String class methods
length()
charAt(int index)
substring(int start, int end)
indexOf(String str)
toLowerCase()
toUpperCase()
trim()
split(String regex)
replace(char oldChar, char newChar)

// Math class methods
Math.abs(int a)
Math.max(int a, int b)
Math.min(int a, int b)
Math.sqrt(double a)
Math.pow(double a, double b)
Math.random()
Math.PI
Math.E

Collection Methods

// List methods
add(element)
get(int index)
set(int index, element)
remove(int index)
size()
isEmpty()
contains(element)
indexOf(element)
clear()

// Map methods
put(key, value)
get(key)
remove(key)
containsKey(key)
containsValue(value)
keySet()
values()
entrySet()
size()

Access Modifiers

public // Accessible from anywhere
protected // Accessible within package and subclasses
default // Accessible within package (no modifier)
private // Accessible only within class

Kotlin

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Kotlin is a statically typed programming language that runs on the JVM, Android, and can be compiled to JavaScript or native code. Developed by JetBrains, it’s designed to be concise, safe, and fully interoperable with Java.

Installation

Kotlin Installation

# Using SDKMAN
sdk install kotlin

# macOS with Homebrew
brew install kotlin

# Manual installation
# Download from https://kotlinlang.org/docs/command-line.html

# Verify installation
kotlin -version
kotlinc -version

IDE Setup

# IntelliJ IDEA (recommended)
# Built-in Kotlin support

# Android Studio
# Built-in Kotlin support

# VS Code
# Install Kotlin extension

Basic Syntax

Hello World

fun main() {
 println("Hello, World!")
}

// Or with arguments
fun main(args: Array<String>) {
 println("Hello, ${args.getOrNull(0) ?: "World"}!")
}

Running Kotlin

# Compile and run
kotlinc hello.kt -include-runtime -d hello.jar
java -jar hello.jar

# Direct execution
kotlin hello.kt

# Interactive shell
kotlinc

Data Types

Basic Types

// Numbers
val byte: Byte = 127
val short: Short = 32767
val int: Int = 2147483647
val long: Long = 9223372036854775807L

// Unsigned numbers
val uByte: UByte = 255u
val uShort: UShort = 65535u
val uInt: UInt = 4294967295u
val uLong: ULong = 18446744073709551615uL

// Floating point
val float: Float = 3.14f
val double: Double = 3.141592653589793

// Character
val char: Char = 'K'

// Boolean
val isKotlin: Boolean = true

// String
val text: String = "Hello, Kotlin!"
val multiline = """
 This is a
 multi-line string
""".trimIndent()

Type Inference

// Type inference
val name = "John" // String
val age = 30 // Int
val height = 5.9 // Double
val isActive = true // Boolean

// Explicit types
val explicitName: String = "John"
val explicitAge: Int = 30

Null Safety

// Non-null types
var name: String = "John"
// name = null // Compilation error

// Nullable types
var nullableName: String? = "John"
nullableName = null // OK

// Safe call operator
val length = nullableName?.length

// Elvis operator
val length2 = nullableName?.length ?: 0

// Not-null assertion
val length3 = nullableName!!.length // Throws NPE if null

Variables and Constants

Variable Declaration

// Mutable variable
var name = "John"
name = "Jane" // OK

// Immutable variable (read-only)
val age = 30
// age = 31 // Compilation error

// Late initialization
lateinit var lateInitVar: String

// Lazy initialization
val lazyValue: String by lazy {
 "Computed only when first accessed"
}

Constants

// Compile-time constants
const val PI = 3.14159
const val MAX_COUNT = 100

// Runtime constants
val currentTime = System.currentTimeMillis()

// Top-level constants
const val API_URL = "https://api.example.com"

Functions

Function Declaration

// Basic function
fun greet(name: String): String {
 return "Hello, $name!"
}

// Single expression function
fun add(a: Int, b: Int) = a + b

// Function with default parameters
fun greet(name: String = "World", prefix: String = "Hello") = "$prefix, $name!"

// Named parameters
greet(prefix = "Hi", name = "John")

// Variable number of arguments
fun sum(vararg numbers: Int): Int {
 return numbers.sum()
}

Higher-Order Functions

// Function as parameter
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
 return operation(x, y)
}

// Usage
val result = calculate(5, 3) { a, b -> a + b }

// Function returning function
fun multiplier(factor: Int): (Int) -> Int {
 return { number -> number * factor }
}

val doubler = multiplier(2)
println(doubler(5)) // 10

Lambda Expressions

// Lambda syntax
val square = { x: Int -> x * x }
val isEven = { x: Int -> x % 2 == 0 }

// Lambda with it parameter
val numbers = listOf(1, 2, 3, 4, 5)
numbers.filter { it > 3 }

// Multiple parameters
val add = { x: Int, y: Int -> x + y }

// Lambda with receiver
val string = StringBuilder().apply {
 append("Hello, ")
 append("World!")
}.toString()

Control Flow

Conditionals

// if expression
val max = if (a > b) a else b

// when expression
when (x) {
 1 -> println("One")
 2, 3 -> println("Two or Three")
 in 4..10 -> println("Between 4 and 10")
 is String -> println("It's a string")
 else -> println("Unknown")
}

// when without argument
when {
 x > 0 -> println("Positive")
 x < 0 -> println("Negative")
 else -> println("Zero")
}

Loops

// for loop
for (i in 1..5) {
 println(i)
}

// for with step
for (i in 1..10 step 2) {
 println(i)
}

// for downTo
for (i in 10 downTo 1) {
 println(i)
}

// for with collections
val items = listOf("apple", "banana", "cherry")
for (item in items) {
 println(item)
}

// for with index
for ((index, item) in items.withIndex()) {
 println("$index: $item")
}

// while loop
var i = 0
while (i < 5) {
 println(i)
 i++
}

// do-while loop
do {
 println(i)
 i++
} while (i < 10)

Control Flow Statements

// break and continue
for (i in 1..10) {
 if (i == 5) continue
 if (i == 8) break
 println(i)
}

// labeled break
loop@ for (i in 1..3) {
 for (j in 1..3) {
 if (i == 2 && j == 2) break@loop
 println("$i, $j")
 }
}

// return from lambda
fun processNumbers(numbers: List<Int>) {
 numbers.forEach { number ->
 if (number < 0) return@forEach // continue
 println(number)
 }
}

Classes and Objects

Class Declaration

class Person(val name: String, var age: Int) {
 // Secondary constructor
 constructor(name: String) : this(name, 0)
 
 // Init block
 init {
 println("Person created: $name")
 }
 
 // Methods
 fun greet() {
 println("Hello, I'm $name")
 }
 
 fun haveBirthday() {
 age++
 }
}

// Usage
val person = Person("John", 30)
person.greet()
person.haveBirthday()

Properties

class Rectangle {
 var width: Double = 0.0
 set(value) {
 if (value > 0) field = value
 }
 
 var height: Double = 0.0
 set(value) {
 if (value > 0) field = value
 }
 
 val area: Double
 get() = width * height
 
 var color: String = "white"
 private set // Private setter
}

Visibility Modifiers

class Example {
 private val privateProperty = "Private"
 protected val protectedProperty = "Protected"
 internal val internalProperty = "Internal"
 public val publicProperty = "Public" // Default
 
 private fun privateFunction() {}
 protected fun protectedFunction() {}
 internal fun internalFunction() {}
 public fun publicFunction() {} // Default
}

Inheritance

Basic Inheritance

// Base class (must be open)
open class Animal(val name: String) {
 open fun makeSound() {
 println("$name makes a sound")
 }
}

// Derived class
class Dog(name: String, val breed: String) : Animal(name) {
 override fun makeSound() {
 println("$name barks")
 }
 
 fun wagTail() {
 println("$name wags tail")
 }
}

// Abstract class
abstract class Shape {
 abstract fun area(): Double
 
 fun describe() {
 println("This shape has area: ${area()}")
 }
}

class Circle(val radius: Double) : Shape() {
 override fun area() = Math.PI * radius * radius
}

Interfaces

interface Drawable {
 fun draw()
 
 // Interface with default implementation
 fun printInfo() {
 println("This is drawable")
 }
}

interface Clickable {
 fun click()
 
 // Default implementation
 fun showClick() = println("Clicked!")
}

class Button : Drawable, Clickable {
 override fun draw() {
 println("Drawing button")
 }
 
 override fun click() {
 println("Button clicked")
 }
}

Data Classes

Data Class

data class User(val name: String, val age: Int, val email: String)

// Automatically generated:
// - equals() and hashCode()
// - toString()
// - componentN() functions
// - copy() function

val user = User("John", 30, "john@example.com")
println(user) // User(name=John, age=30, email=john@example.com)

// Destructuring
val (name, age, email) = user

// Copy with modifications
val olderUser = user.copy(age = 31)

Enum Classes

enum class Direction {
 NORTH, SOUTH, EAST, WEST
}

enum class Color(val rgb: Int) {
 RED(0xFF0000),
 GREEN(0x00FF00),
 BLUE(0x0000FF);
 
 fun containsRed() = (this.rgb and 0xFF0000 != 0)
}

// Usage
val direction = Direction.NORTH
val color = Color.RED
println(color.rgb)

Sealed Classes

sealed class Result<out T>
data class Success<T>(val data: T) : Result<T>()
data class Error(val message: String) : Result<Nothing>()
object Loading : Result<Nothing>()

// Usage with when
fun handleResult(result: Result<String>) {
 when (result) {
 is Success -> println("Data: ${result.data}")
 is Error -> println("Error: ${result.message}")
 Loading -> println("Loading...")
 }
}

Collections

Lists

// Immutable list
val readOnlyList = listOf("apple", "banana", "cherry")

// Mutable list
val mutableList = mutableListOf("apple", "banana")
mutableList.add("cherry")
mutableList.remove("banana")

// List operations
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
val filtered = numbers.filter { it > 3 }
val first = numbers.first()
val last = numbers.last()

Sets

// Immutable set
val readOnlySet = setOf("apple", "banana", "cherry")

// Mutable set
val mutableSet = mutableSetOf("apple", "banana")
mutableSet.add("cherry")
mutableSet.remove("banana")

// Set operations
val set1 = setOf(1, 2, 3)
val set2 = setOf(3, 4, 5)
val union = set1 union set2
val intersection = set1 intersect set2
val difference = set1 subtract set2

Maps

// Immutable map
val readOnlyMap = mapOf("a" to 1, "b" to 2, "c" to 3)

// Mutable map
val mutableMap = mutableMapOf("a" to 1, "b" to 2)
mutableMap["c"] = 3
mutableMap.remove("b")

// Map operations
val map = mapOf("name" to "John", "age" to "30")
val name = map["name"]
val age = map.getValue("age")
val keys = map.keys
val values = map.values

Collection Operations

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// Transformations
val doubled = numbers.map { it * 2 }
val strings = numbers.map { "Number: $it" }

// Filtering
val evens = numbers.filter { it % 2 == 0 }
val odds = numbers.filterNot { it % 2 == 0 }

// Aggregation
val sum = numbers.sum()
val average = numbers.average()
val max = numbers.maxOrNull()
val min = numbers.minOrNull()

// Grouping
val grouped = numbers.groupBy { it % 3 }

// Sorting
val sorted = numbers.sorted()
val sortedDesc = numbers.sortedDescending()

Coroutines

Basic Coroutines

import kotlinx.coroutines.*

// Simple coroutine
fun main() = runBlocking {
 launch {
 delay(1000L)
 println("World!")
 }
 println("Hello,")
}

// Async coroutine
fun main() = runBlocking {
 val deferred = async {
 delay(1000L)
 "Hello"
 }
 println("${deferred.await()}, World!")
}

Suspending Functions

suspend fun fetchData(): String {
 delay(1000L) // Simulate network call
 return "Data"
}

suspend fun processData(data: String): String {
 delay(500L) // Simulate processing
 return "Processed: $data"
}

// Usage
fun main() = runBlocking {
 val data = fetchData()
 val processed = processData(data)
 println(processed)
}

Coroutine Builders

// runBlocking - blocks current thread
runBlocking {
 // coroutine code
}

// launch - fire and forget
launch {
 // coroutine code
}

// async - concurrent execution with result
val deferred = async {
 // return some value
}
val result = deferred.await()

// withContext - change context
withContext(Dispatchers.IO) {
 // IO operations
}

Channels

import kotlinx.coroutines.channels.*

// Channel for communication
val channel = Channel<Int>()

launch {
 for (x in 1..5) {
 channel.send(x * x)
 }
 channel.close()
}

launch {
 for (y in channel) {
 println(y)
 }
}

// Produce builder
val squares = produce<Int> {
 for (x in 1..5) {
 send(x * x)
 }
}

Extension Functions

Basic Extensions

// Extension function for String
fun String.isPalindrome(): Boolean {
 return this == this.reversed()
}

// Usage
val text = "racecar"
println(text.isPalindrome()) // true

// Extension property
val String.lastChar: Char
 get() = this[length - 1]

// Extension with receiver
fun StringBuilder.appendLine(text: String) = this.append("$text\n")

Generic Extensions

// Generic extension function
fun <T> List<T>.second(): T {
 if (size < 2) throw IndexOutOfBoundsException()
 return this[1]
}

// Usage
val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.second()) // 2

Delegation

Class Delegation

interface Base {
 fun print()
}

class BaseImpl(val x: Int) : Base {
 override fun print() { println(x) }
}

class Derived(b: Base) : Base by b

// Usage
val base = BaseImpl(10)
val derived = Derived(base)
derived.print() // 10

Property Delegation

import kotlin.properties.Delegates

class User {
 // Lazy property
 val name: String by lazy {
 println("Computed!")
 "John"
 }
 
 // Observable property
 var age: Int by Delegates.observable(0) { property, oldValue, newValue ->
 println("${property.name} changed from $oldValue to $newValue")
 }
 
 // Vetoable property
 var salary: Double by Delegates.vetoable(0.0) { property, oldValue, newValue ->
 newValue >= 0.0
 }
}

Type System

Generics

// Generic class
class Box<T>(val value: T)

// Generic function
fun <T> singletonList(item: T): List<T> {
 return listOf(item)
}

// Multiple type parameters
class Pair<A, B>(val first: A, val second: B)

// Bounded type parameters
fun <T : Comparable<T>> sort(list: List<T>): List<T> {
 return list.sorted()
}

Variance

// Covariance (out)
interface Producer<out T> {
 fun produce(): T
}

// Contravariance (in)
interface Consumer<in T> {
 fun consume(item: T)
}

// Invariance (default)
interface Processor<T> {
 fun process(item: T): T
}

Type Aliases

typealias UserId = String
typealias UserMap = Map<UserId, String>

// Function type alias
typealias Predicate<T> = (T) -> Boolean

// Usage
val isEven: Predicate<Int> = { it % 2 == 0 }

Standard Library

String Operations

val text = "Hello, Kotlin!"

// String templates
val name = "John"
val greeting = "Hello, $name!"
val info = "Name: ${name.uppercase()}"

// String operations
text.uppercase()
text.lowercase()
text.substring(0, 5)
text.replace("Kotlin", "World")
text.split(", ")

// String builder
val sb = StringBuilder()
sb.append("Hello")
sb.append(", ")
sb.append("World!")
val result = sb.toString()

File Operations

import java.io.File

// Read file
val file = File("example.txt")
val content = file.readText()
val lines = file.readLines()

// Write file
file.writeText("Hello, World!")
file.appendText("\nNew line")

// File operations
if (file.exists()) {
 println("File size: ${file.length()}")
}

// Working with paths
val path = file.toPath()
val absolutePath = file.absolutePath

Date and Time

import java.time.*
import java.time.format.DateTimeFormatter

// Current time
val now = LocalDateTime.now()
val today = LocalDate.now()
val currentTime = LocalTime.now()

// Creating dates
val specificDate = LocalDate.of(2023, 12, 25)
val specificTime = LocalTime.of(14, 30, 0)

// Formatting
val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
val formatted = now.format(formatter)

// Parsing
val parsed = LocalDateTime.parse("2023-12-25 14:30:00", formatter)

Testing

Unit Testing

import org.junit.Test
import org.junit.Assert.*

class CalculatorTest {
 
 @Test
 fun testAddition() {
 val calculator = Calculator()
 val result = calculator.add(2, 3)
 assertEquals(5, result)
 }
 
 @Test
 fun testDivision() {
 val calculator = Calculator()
 val result = calculator.divide(10, 2)
 assertEquals(5.0, result, 0.001)
 }
 
 @Test(expected = IllegalArgumentException::class)
 fun testDivisionByZero() {
 val calculator = Calculator()
 calculator.divide(10, 0)
 }
}

Coroutine Testing

import kotlinx.coroutines.test.*

class CoroutineTest {
 
 @Test
 fun testSuspendFunction() = runTest {
 val result = suspendingFunction()
 assertEquals("Expected", result)
 }
 
 @Test
 fun testWithDelay() = runTest {
 val startTime = currentTime
 delay(1000)
 val endTime = currentTime
 assertEquals(1000, endTime - startTime)
 }
}

Best Practices

Null Safety

// Use safe calls
val length = text?.length

// Use elvis operator for defaults
val length = text?.length ?: 0

// Use let for null checks
text?.let { nonNullText ->
 println(nonNullText.uppercase())
}

// Use requireNotNull for validation
fun processText(text: String?) {
 val nonNullText = requireNotNull(text) { "Text cannot be null" }
 // Process non-null text
}

Immutability

// Prefer val over var
val immutableList = listOf(1, 2, 3)
val immutableMap = mapOf("a" to 1, "b" to 2)

// Use data classes for immutable data
data class User(val name: String, val age: Int)

// Use copy for modifications
val originalUser = User("John", 30)
val modifiedUser = originalUser.copy(age = 31)

Functional Programming

// Use higher-order functions
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
val filtered = numbers.filter { it > 3 }

// Use sequences for large collections
val result = numbers.asSequence()
 .filter { it > 2 }
 .map { it * 2 }
 .toList()

// Use apply, let, run, also, with
val user = User("John", 30).apply {
 // Configure object
}

Android Development

Activity

class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)
 
 // Initialize views
 val button = findViewById<Button>(R.id.button)
 button.setOnClickListener {
 // Handle click
 }
 }
}

ViewBinding

class MainActivity : AppCompatActivity() {
 private lateinit var binding: ActivityMainBinding
 
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 binding = ActivityMainBinding.inflate(layoutInflater)
 setContentView(binding.root)
 
 binding.button.setOnClickListener {
 binding.textView.text = "Button clicked!"
 }
 }
}

Room Database

@Entity
data class User(
 @PrimaryKey val id: Int,
 val name: String,
 val email: String
)

@Dao
interface UserDao {
 @Query("SELECT * FROM user")
 suspend fun getAllUsers(): List<User>
 
 @Insert
 suspend fun insertUser(user: User)
 
 @Delete
 suspend fun deleteUser(user: User)
}

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
 abstract fun userDao(): UserDao
}

Quick Reference

Variable Declaration

val immutable = "Cannot change"
var mutable = "Can change"
lateinit var lateInit: String
val lazy: String by lazy { "Computed when needed" }

Function Declaration

fun functionName(param: Type): ReturnType {
 return value
}

fun singleExpression(x: Int) = x * 2
fun defaultParams(x: Int = 0) = x
fun varargs(vararg items: String) = items.toList()

Classes

class ClassName(val property: Type) {
 fun method() {}
}

data class DataClass(val prop: Type)
object Singleton
sealed class SealedClass

Collections

listOf(1, 2, 3) // Immutable list
mutableListOf(1, 2, 3) // Mutable list
setOf(1, 2, 3) // Immutable set
mapOf("a" to 1, "b" to 2) // Immutable map

Coroutines

runBlocking { /* code */ }
launch { /* fire and forget */ }
async { /* return value */ }
suspend fun name() { /* suspending function */ }

Null Safety

var nullable: String? = null
val length = nullable?.length
val lengthOrZero = nullable?.length ?: 0
val definitelyNotNull = nullable!!

Python

Sun, 01 Jan 2023 00:00:00 +0000

Overview

Python is a high-level, interpreted programming language known for its simplicity and readability. It’s widely used for web development, data science, automation, artificial intelligence, and rapid prototyping.

Installation

Python Installation

# Ubuntu/Debian
sudo apt install python3 python3-pip

# macOS
brew install python3

# Windows
# Download from https://python.org/downloads/

# Check version
python3 --version
pip3 --version

Package Management

# Install package
pip install package_name

# Install specific version
pip install package_name==1.2.3

# Install from requirements file
pip install -r requirements.txt

# List installed packages
pip list

# Create virtual environment
python3 -m venv myenv
source myenv/bin/activate # Linux/Mac
myenv\Scripts\activate # Windows

Basic Syntax

Hello World

print("Hello, World!")

# Multi-line string
message = """
This is a
multi-line string
"""
print(message)

Running Python

# Interactive mode
python3

# Run script
python3 script.py

# Run module
python3 -m module_name

# One-liner
python3 -c "print('Hello, World!')"

Data Types

Basic Types

# Numbers
integer = 42
float_num = 3.14
complex_num = 3 + 4j

# String
text = "Hello, World!"
multiline = """Line 1
Line 2
Line 3"""

# Boolean
flag = True
is_valid = False

# None
value = None

Type Checking

# Type function
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("hello")) # <class 'str'>

# isinstance function
print(isinstance(42, int)) # True
print(isinstance(3.14, float)) # True
print(isinstance("hello", str)) # True

Type Conversion

# String to number
num = int("123")
float_num = float("3.14")

# Number to string
text = str(123)
text = str(3.14)

# List to string
numbers = [1, 2, 3]
text = str(numbers)
joined = ", ".join(map(str, numbers))

Variables and Constants

Variable Assignment

# Basic assignment
x = 10
y = 20

# Multiple assignment
a, b, c = 1, 2, 3
x = y = z = 0

# Swapping
a, b = b, a

# Unpacking
numbers = [1, 2, 3]
first, second, third = numbers

Constants (Convention)

# Constants are uppercase by convention
PI = 3.14159
MAX_SIZE = 1000
API_URL = "https://api.example.com"

# Use enum for related constants
from enum import Enum

class Status(Enum):
 PENDING = 1
 APPROVED = 2
 REJECTED = 3

Strings

String Operations

# String creation
name = "John"
greeting = 'Hello'
template = f"Hello, {name}!"

# String methods
text = "Hello, World!"
print(text.upper()) # HELLO, WORLD!
print(text.lower()) # hello, world!
print(text.title()) # Hello, World!
print(text.replace("World", "Python")) # Hello, Python!
print(text.split(",")) # ['Hello', ' World!']
print(text.strip()) # Remove whitespace
print(text.startswith("Hello")) # True
print(text.endswith("!")) # True

String Formatting

name = "Alice"
age = 30

# f-strings (Python 3.6+)
message = f"My name is {name} and I'm {age} years old"

# format method
message = "My name is {} and I'm {} years old".format(name, age)
message = "My name is {name} and I'm {age} years old".format(name=name, age=age)

# % formatting (older style)
message = "My name is %s and I'm %d years old" % (name, age)

# Advanced formatting
number = 3.14159
formatted = f"{number:.2f}" # 3.14

String Indexing and Slicing

text = "Python"

# Indexing
print(text[0]) # P
print(text[-1]) # n

# Slicing
print(text[1:4]) # yth
print(text[:3]) # Pyt
print(text[2:]) # thon
print(text[::-1]) # nohtyP (reverse)

Data Structures

Lists

# List creation
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
empty = []

# List methods
numbers.append(6) # Add to end
numbers.insert(0, 0) # Insert at index
numbers.remove(3) # Remove first occurrence
popped = numbers.pop() # Remove and return last
numbers.extend([7, 8]) # Add multiple items
numbers.sort() # Sort in place
numbers.reverse() # Reverse in place

# List comprehension
squares = [x**2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]

Tuples

# Tuple creation
coordinates = (10, 20)
single = (42,) # Single element tuple
empty = ()

# Tuple unpacking
x, y = coordinates

# Named tuples
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)

Dictionaries

# Dictionary creation
person = {"name": "John", "age": 30, "city": "New York"}
empty = {}

# Dictionary methods
person["email"] = "john@example.com" # Add/update
age = person.get("age", 0) # Get with default
person.pop("city") # Remove and return
person.update({"country": "USA"}) # Update multiple

# Dictionary comprehension
squares = {x: x**2 for x in range(5)}
filtered = {k: v for k, v in person.items() if v != "John"}

# Iteration
for key in person:
 print(key, person[key])

for key, value in person.items():
 print(key, value)

Sets

# Set creation
numbers = {1, 2, 3, 4, 5}
empty = set()

# Set operations
numbers.add(6) # Add element
numbers.remove(3) # Remove element (raises error if not found)
numbers.discard(3) # Remove element (no error if not found)

# Set operations
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2 # {1, 2, 3, 4, 5}
intersection = set1 & set2 # {3}
difference = set1 - set2 # {1, 2}

Control Structures

Conditionals

# if-elif-else
x = 10
if x > 0:
 print("Positive")
elif x < 0:
 print("Negative")
else:
 print("Zero")

# Ternary operator
result = "positive" if x > 0 else "not positive"

# Multiple conditions
if x > 0 and x < 100:
 print("Between 0 and 100")

if x < 0 or x > 100:
 print("Outside range")

Loops

# for loop
for i in range(5):
 print(i)

# for loop with list
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
 print(fruit)

# for loop with index
for i, fruit in enumerate(fruits):
 print(f"{i}: {fruit}")

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

# Loop control
for i in range(10):
 if i == 3:
 continue # Skip iteration
 if i == 7:
 break # Exit loop
 print(i)

Loop Patterns

# Loop with else
for i in range(5):
 if i == 10:
 break
else:
 print("Loop completed normally")

# Nested loops
for i in range(3):
 for j in range(3):
 print(f"({i}, {j})")

# Dictionary iteration
person = {"name": "John", "age": 30}
for key, value in person.items():
 print(f"{key}: {value}")

Functions

Function Definition

# Basic function
def greet(name):
 return f"Hello, {name}!"

# Function with default parameters
def greet(name="World"):
 return f"Hello, {name}!"

# Function with multiple parameters
def add(a, b):
 return a + b

# Function with variable arguments
def sum_all(*args):
 return sum(args)

# Function with keyword arguments
def create_profile(**kwargs):
 return kwargs

# Mixed arguments
def process_data(required, *args, **kwargs):
 print(f"Required: {required}")
 print(f"Args: {args}")
 print(f"Kwargs: {kwargs}")

Lambda Functions

# Lambda function
square = lambda x: x**2
add = lambda x, y: x + y

# Lambda with higher-order functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

Decorators

# Simple decorator
def my_decorator(func):
 def wrapper():
 print("Before function")
 result = func()
 print("After function")
 return result
 return wrapper

@my_decorator
def say_hello():
 print("Hello!")

# Decorator with arguments
def timing_decorator(func):
 import time
 def wrapper(*args, **kwargs):
 start = time.time()
 result = func(*args, **kwargs)
 end = time.time()
 print(f"{func.__name__} took {end - start:.2f} seconds")
 return result
 return wrapper

@timing_decorator
def slow_function():
 time.sleep(1)
 return "Done"

Object-Oriented Programming

Classes and Objects

class Person:
 # Class variable
 species = "Homo sapiens"
 
 # Constructor
 def __init__(self, name, age):
 self.name = name # Instance variable
 self.age = age
 
 # Instance method
 def greet(self):
 return f"Hello, I'm {self.name}"
 
 # Class method
 @classmethod
 def create_child(cls, name):
 return cls(name, 0)
 
 # Static method
 @staticmethod
 def is_adult(age):
 return age >= 18
 
 # String representation
 def __str__(self):
 return f"Person(name={self.name}, age={self.age})"

# Usage
person = Person("Alice", 30)
print(person.greet())
print(person)

Inheritance

# Base class
class Animal:
 def __init__(self, name):
 self.name = name
 
 def make_sound(self):
 pass
 
 def info(self):
 return f"I am {self.name}"

# Derived class
class Dog(Animal):
 def __init__(self, name, breed):
 super().__init__(name) # Call parent constructor
 self.breed = breed
 
 def make_sound(self):
 return "Woof!"
 
 def info(self):
 return f"{super().info()} and I'm a {self.breed}"

# Usage
dog = Dog("Buddy", "Golden Retriever")
print(dog.info())
print(dog.make_sound())

Properties and Magic Methods

class Circle:
 def __init__(self, radius):
 self._radius = radius
 
 @property
 def radius(self):
 return self._radius
 
 @radius.setter
 def radius(self, value):
 if value < 0:
 raise ValueError("Radius cannot be negative")
 self._radius = value
 
 @property
 def area(self):
 return 3.14159 * self._radius ** 2
 
 # Magic methods
 def __str__(self):
 return f"Circle(radius={self.radius})"
 
 def __repr__(self):
 return f"Circle({self.radius})"
 
 def __eq__(self, other):
 return self.radius == other.radius
 
 def __lt__(self, other):
 return self.radius < other.radius

# Usage
circle = Circle(5)
print(circle.area)
circle.radius = 10
print(circle)

Error Handling

Try-Except

try:
 result = 10 / 0
except ZeroDivisionError:
 print("Cannot divide by zero")
except ValueError as e:
 print(f"Value error: {e}")
except Exception as e:
 print(f"General error: {e}")
else:
 print("No error occurred")
finally:
 print("This always runs")

Custom Exceptions

class CustomError(Exception):
 def __init__(self, message):
 self.message = message
 super().__init__(self.message)

def validate_age(age):
 if age < 0:
 raise CustomError("Age cannot be negative")
 if age > 150:
 raise CustomError("Age seems unrealistic")
 return age

# Usage
try:
 validate_age(-5)
except CustomError as e:
 print(e.message)

File I/O

Reading Files

# Read entire file
with open('file.txt', 'r') as f:
 content = f.read()

# Read line by line
with open('file.txt', 'r') as f:
 for line in f:
 print(line.strip())

# Read all lines
with open('file.txt', 'r') as f:
 lines = f.readlines()

# Read with error handling
try:
 with open('file.txt', 'r') as f:
 content = f.read()
except FileNotFoundError:
 print("File not found")
except IOError:
 print("Error reading file")

Writing Files

# Write to file
with open('output.txt', 'w') as f:
 f.write("Hello, World!\n")
 f.write("Second line\n")

# Append to file
with open('output.txt', 'a') as f:
 f.write("Appended line\n")

# Write list to file
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open('output.txt', 'w') as f:
 f.writelines(lines)

JSON Files

import json

# Write JSON
data = {"name": "John", "age": 30, "city": "New York"}
with open('data.json', 'w') as f:
 json.dump(data, f, indent=2)

# Read JSON
with open('data.json', 'r') as f:
 data = json.load(f)

# JSON strings
json_string = json.dumps(data)
data = json.loads(json_string)

Modules and Packages

Importing

# Import entire module
import math
print(math.sqrt(16))

# Import specific functions
from math import sqrt, pi
print(sqrt(16))

# Import with alias
import numpy as np
import pandas as pd

# Import all (not recommended)
from math import *

Creating Modules

# utils.py
def add(a, b):
 return a + b

def multiply(a, b):
 return a * b

# main.py
import utils
result = utils.add(5, 3)

# Or
from utils import add, multiply
result = add(5, 3)

Package Structure

mypackage/
 __init__.py
 module1.py
 module2.py
 subpackage/
 __init__.py
 submodule.py

Standard Library

Common Modules

# os - Operating system interface
import os
current_dir = os.getcwd()
os.mkdir('new_directory')
os.remove('file.txt')

# sys - System-specific parameters
import sys
print(sys.version)
sys.exit(0)

# datetime - Date and time handling
from datetime import datetime, date, timedelta
now = datetime.now()
today = date.today()
future = now + timedelta(days=7)

# random - Random number generation
import random
random_int = random.randint(1, 10)
random_choice = random.choice(['apple', 'banana', 'orange'])
random.shuffle(my_list)

# collections - Specialized container datatypes
from collections import Counter, defaultdict, deque
counter = Counter(['a', 'b', 'a', 'c', 'b', 'a'])
dd = defaultdict(list)
queue = deque([1, 2, 3])

Regular Expressions

import re

# Match patterns
pattern = r'\d+'
text = "I have 5 apples and 3 oranges"
matches = re.findall(pattern, text) # ['5', '3']

# Replace patterns
new_text = re.sub(r'\d+', 'X', text) # "I have X apples and X oranges"

# Search and groups
pattern = r'(\w+)@(\w+\.\w+)'
email = "user@example.com"
match = re.search(pattern, email)
if match:
 username = match.group(1)
 domain = match.group(2)

List Comprehensions and Generators

List Comprehensions

# Basic list comprehension
squares = [x**2 for x in range(10)]

# With condition
evens = [x for x in range(20) if x % 2 == 0]

# Nested comprehension
matrix = [[i*j for j in range(3)] for i in range(3)]

# Dictionary comprehension
word_lengths = {word: len(word) for word in ['hello', 'world', 'python']}

# Set comprehension
unique_lengths = {len(word) for word in ['hello', 'world', 'python']}

Generators

# Generator function
def fibonacci(n):
 a, b = 0, 1
 for _ in range(n):
 yield a
 a, b = b, a + b

# Usage
fib = fibonacci(10)
for num in fib:
 print(num)

# Generator expression
squares = (x**2 for x in range(10))
print(list(squares))

Advanced Features

Context Managers

# Custom context manager
class FileManager:
 def __init__(self, filename, mode):
 self.filename = filename
 self.mode = mode
 self.file = None
 
 def __enter__(self):
 self.file = open(self.filename, self.mode)
 return self.file
 
 def __exit__(self, exc_type, exc_val, exc_tb):
 if self.file:
 self.file.close()

# Usage
with FileManager('test.txt', 'w') as f:
 f.write('Hello, World!')

# Using contextlib
from contextlib import contextmanager

@contextmanager
def timer():
 import time
 start = time.time()
 yield
 end = time.time()
 print(f"Time elapsed: {end - start:.2f} seconds")

# Usage
with timer():
 # Some time-consuming operation
 time.sleep(1)

Iterators

class Counter:
 def __init__(self, max_count):
 self.max_count = max_count
 self.count = 0
 
 def __iter__(self):
 return self
 
 def __next__(self):
 if self.count < self.max_count:
 self.count += 1
 return self.count
 else:
 raise StopIteration

# Usage
counter = Counter(3)
for num in counter:
 print(num) # 1, 2, 3

Popular Libraries

NumPy

import numpy as np

# Create arrays
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])
zeros = np.zeros((3, 3))
ones = np.ones((2, 2))

# Array operations
result = arr * 2
dot_product = np.dot(matrix, matrix)

Pandas

import pandas as pd

# Create DataFrame
df = pd.DataFrame({
 'name': ['Alice', 'Bob', 'Charlie'],
 'age': [25, 30, 35],
 'city': ['New York', 'London', 'Tokyo']
})

# DataFrame operations
filtered = df[df['age'] > 25]
grouped = df.groupby('city').mean()

Requests

import requests

# GET request
response = requests.get('https://api.example.com/data')
if response.status_code == 200:
 data = response.json()

# POST request
payload = {'key': 'value'}
response = requests.post('https://api.example.com/create', json=payload)

Testing

Unit Testing

import unittest

class TestMathFunctions(unittest.TestCase):
 def test_add(self):
 self.assertEqual(add(2, 3), 5)
 self.assertEqual(add(-1, 1), 0)
 
 def test_divide(self):
 self.assertEqual(divide(10, 2), 5)
 with self.assertRaises(ZeroDivisionError):
 divide(10, 0)
 
 def setUp(self):
 # Run before each test
 self.calculator = Calculator()
 
 def tearDown(self):
 # Run after each test
 pass

if __name__ == '__main__':
 unittest.main()

Pytest

import pytest

def test_add():
 assert add(2, 3) == 5
 assert add(-1, 1) == 0

def test_divide():
 assert divide(10, 2) == 5
 with pytest.raises(ZeroDivisionError):
 divide(10, 0)

# Fixtures
@pytest.fixture
def sample_data():
 return [1, 2, 3, 4, 5]

def test_sum(sample_data):
 assert sum(sample_data) == 15

Best Practices

Code Style (PEP 8)

# Good
def calculate_area(radius):
 """Calculate the area of a circle."""
 pi = 3.14159
 return pi * radius ** 2

# Variable naming
user_name = "john_doe"
MAX_RETRIES = 3

# Class naming
class UserManager:
 pass

# Constants
API_BASE_URL = "https://api.example.com"

Documentation

def fibonacci(n):
 """
 Generate Fibonacci sequence up to n terms.
 
 Args:
 n (int): Number of terms to generate
 
 Returns:
 list: List of Fibonacci numbers
 
 Raises:
 ValueError: If n is negative
 """
 if n < 0:
 raise ValueError("n must be non-negative")
 
 if n <= 1:
 return [0] if n == 1 else []
 
 fib = [0, 1]
 for i in range(2, n):
 fib.append(fib[i-1] + fib[i-2])
 
 return fib

Virtual Environments

# Create virtual environment
python3 -m venv myenv

# Activate
source myenv/bin/activate # Linux/Mac
myenv\Scripts\activate # Windows

# Install packages
pip install requests pandas

# Save requirements
pip freeze > requirements.txt

# Deactivate
deactivate

Performance Tips

Optimization

# Use list comprehensions instead of loops
squares = [x**2 for x in range(1000)] # Faster
squares = []
for x in range(1000):
 squares.append(x**2) # Slower

# Use generators for large datasets
def large_sequence():
 for i in range(1000000):
 yield i * 2

# Use built-in functions
numbers = [1, 2, 3, 4, 5]
total = sum(numbers) # Faster than manual loop

# Use sets for membership testing
large_set = set(range(1000))
if 500 in large_set: # O(1) average case
 print("Found")

Memory Management

# Use slots for memory-efficient classes
class Point:
 __slots__ = ['x', 'y']
 
 def __init__(self, x, y):
 self.x = x
 self.y = y

# Use generators for large datasets
def read_large_file(filename):
 with open(filename) as f:
 for line in f:
 yield line.strip()

# Profile code
import cProfile
cProfile.run('my_function()')

Debugging

Print Debugging

def debug_function(x, y):
 print(f"Input: x={x}, y={y}")
 result = x + y
 print(f"Result: {result}")
 return result

# Using pdb
import pdb
pdb.set_trace() # Debugger will stop here

Logging

import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Use logging instead of print
logger.info("This is an info message")
logger.warning("This is a warning")
logger.error("This is an error")

Quick Reference

Built-in Functions

len(obj) # Length
type(obj) # Type
isinstance(obj, type) # Type checking
str(obj) # String conversion
int(obj) # Integer conversion
float(obj) # Float conversion
list(obj) # List conversion
dict(obj) # Dictionary conversion
max(iterable) # Maximum value
min(iterable) # Minimum value
sum(iterable) # Sum of values
sorted(iterable) # Sorted list
reversed(iterable) # Reversed iterator
enumerate(iterable) # Index-value pairs
zip(iter1, iter2) # Parallel iteration

String Methods

s.lower() # Lowercase
s.upper() # Uppercase
s.strip() # Remove whitespace
s.split(sep) # Split string
s.join(iterable) # Join strings
s.replace(old, new) # Replace substring
s.startswith(prefix) # Check prefix
s.endswith(suffix) # Check suffix
s.find(substring) # Find position
s.isdigit() # Check if digits
s.isalpha() # Check if alphabetic

List Methods

l.append(item) # Add to end
l.insert(i, item) # Insert at index
l.remove(item) # Remove first occurrence
l.pop(i) # Remove and return
l.sort() # Sort in place
l.reverse() # Reverse in place
l.extend(iterable) # Add multiple items
l.index(item) # Find index
l.count(item) # Count occurrences

Programming on QuickRef - Personal Developer Reference

Bash

Overview

Variables

Special Variables

String Operations

Arrays

Conditionals

Test Conditions

Loops

For Loop

While Loop

Until Loop

Functions

Input/Output

File Operations

Process Control

Error Handling

Advanced Features

Command Substitution

Parameter Expansion

Arithmetic

Best Practices

Common Patterns

Argument Parsing

Script Template

See Also

C

Overview

Installation

Compilers

Build Tools

Basic Syntax

Hello World

Compilation

Data Types

Primitive Types

Size Information

Constants and Macros

Variables and Scope

Variable Declaration

Scope

Functions

Function Declaration and Definition

Function Pointers

Variadic Functions

Control Structures

Conditionals

Loops

Arrays and Strings

Arrays

Strings

String Manipulation

Pointers

Basic Pointers

Pointer Arithmetic

Pointers and Functions

Double Pointers

Memory Management

Dynamic Memory Allocation

Memory Management Best Practices

Structures and Unions

Structures

Typedef

Unions

Bit Fields

File I/O

File Operations

File Modes

Formatted I/O

Binary I/O

Preprocessor

Macros

Header Guards

Include Files

Error Handling

Error Codes

Error Messages

Assert

Standard Library