LOADING

Michael Henry Tirkey

Full Stack Developer & AI Enthusiast

Building innovative mobile and web solutions with over a decade of expertise

View Projects Get In Touch

About Me

Journey & Expertise

With over a decade of expertise in Android development, I've successfully navigated the intricacies of Mobile, Watch OS, and Tablet applications. My professional journey spans on-site projects in the U.S. and India, along with freelance work which showcases my quick adaptability and commitment to deliver high-quality tech solutions.

As a versatile programmer, I've evolved from web development in 2013 to a Full Stack MERN developer, working on AI-based solutions, proficient in Kotlin, Java, and JavaScript. This diverse skill set empowers me to handle projects across Android, Web, and Desktop platforms.

11+ Years Experience
75+ Projects Completed
8 Companies Worked

Technical Skills

Mobile Development

Android (Kotlin/Java)
Jetpack Compose
Flutter (Dart)
React Native

Web Development

JavaScript/TypeScript
React/Next.js
Node.js/Express
HTML5/CSS3
Three.js/Anime.js

Backend & Database

Java/Spring
MongoDB/MySQL
Firebase/SQLite
REST/SOAP APIs

Tools & Workflows

Android Studio/IntelliJ
Git/GitHub/SVN
JIRA/Trello/Confluence
Adobe Creative Suite

AI & Machine Learning

Python/TensorFlow
AI Content Generation
Computer Vision/OpenCV
NLP/Classification

Professional Experience

Sep 2018 - Jun 2019

Grit Innovation

Senior Android Developer

Hyderabad, India

  • Built business solutions for financial clients like Magma Fincorp & Bajaj Finances
  • Developed dynamic functionality using in-house form engine
  • Created native applications for banking and loan solutions
Nov 2017 - Apr 2018

The Home Depot

Android Developer

Irving, Texas, USA

  • Developed The Home Depot mobile application
  • Implemented product browsing and in-app purchase features
  • Enhanced user experience for home goods and furniture shopping
Apr 2017 - Oct 2017

Verizon Communications

Android Developer

Virginia, USA

  • Built internal application for network traffic monitoring
  • Developed network diagnostic tools
  • Implemented user traffic tracking functionality
Apr 2016 - Feb 2017

AT&T

Android Developer

Atlanta, Georgia, USA

  • Developed Digital Life Home security application
  • Implemented device monitoring and control features
  • Built dynamic content and security modules through Digital Hub
Aug 2015 - Dec 2015

Best Buy

Android Developer

Seattle, Washington, USA

  • Built Geek Squad application using native Android tools
  • Created custom UI elements with Marshmallow API
  • Developed product/services query functionality
Feb 2015 - Aug 2015

Time Razor

Android Developer

Leesburg, Virginia, USA

  • Event browsing application with custom UI controls
  • Consumed in-house public event management system
  • Implemented Build Flavors for different audiences
Oct 2014 - Jan 2015

DISYS

Android Developer

McLean, Virginia, USA

  • Developed Hangit - local deals and events application
  • Built for both handset and tablet platforms
  • Implemented event-based campaigns and daily deals
Nov 2013 - Feb 2014

Verizon Wireless

Android Developer

Waltham, Massachusetts, USA

  • Developed SlideShare with in-app call experience
  • Implemented group sessions, chats, and private communications
  • Built using Android Service for seamless user experience

Featured Projects

NCGA Mobile App

Government project developed for Beekeeper Group - comprehensive mobile application with advanced government service features

Android Java REST API SQLite Government
Live Demo GitHub

COVID Tracker

Real-time COVID-19 tracking and monitoring application developed for OnSiteMedServices with health data analytics

Android Kotlin Firebase Real-time DB Healthcare
Live Demo GitHub

FaceGuard Security

Advanced phone security application with facial recognition, monitoring capabilities, and comprehensive device protection

Android Java OpenCV Computer Vision Security
Live Demo GitHub

TimeCoyl Watch App

Android Watch application for OutbreakCreative Ltd with various custom watchfaces and Google Calendar integration

Android Wear Kotlin Google Calendar API Watchfaces Wearables
Live Demo GitHub

Gemini AI Classifier

AI-powered content classification and generation system using modern machine learning and natural language processing

Python TensorFlow Gemini AI NLP Classification
Live Demo GitHub

Social Media Platform

Full-stack social media application with real-time messaging, content sharing, and interactive user engagement features

MERN Stack Socket.io MongoDB Real-time Social
Live Demo GitHub

AI Content Generator

MERN Stack application with AI integration for automated content generation and intelligent classification systems

React Node.js AI/ML TensorFlow Content Gen
Live Demo GitHub

Enterprise Solutions

Collection of enterprise mobile solutions including banking apps for Magma Fincorp, Bajaj Finances, and corporate applications

Android Java/Kotlin Enterprise Banking Security
Live Demo GitHub

Tech Insights & Articles

Android

Mastering State Management in Jetpack Compose

Learn the fundamentals of state management in Jetpack Compose, from remember and mutableStateOf to advanced patterns like StateFlow, ViewModel integration, and handling complex UI state. Perfect for building reactive and performant Android apps.

Dec 15, 2024 12 min read
Jetpack Compose State Management Kotlin
Read Article
Android

Advanced Animation Techniques in Jetpack Compose

Dive deep into Compose animations - from basic animateFloatAsState to complex shared element transitions. Learn to create smooth, delightful user experiences with spring animations, gesture-driven animations, and custom transitions.

Dec 12, 2024 15 min read
Animations UI/UX Material Design
Read Article
Android

Building Custom Composables: Design System Fundamentals

Create reusable, consistent UI components with custom Composables. Learn design system principles, theming with Material3, custom modifiers, and how to build a scalable component library that your entire team can use effectively.

Dec 8, 2024 10 min read
Design System Material3 Custom Components
Read Article
Android

Performance Optimization in Large Compose Applications

Essential techniques for keeping your Compose apps fast and responsive. Learn about recomposition optimization, LazyColumn best practices, memory management, and profiling tools to identify and fix performance bottlenecks.

Dec 5, 2024 14 min read
Performance Optimization Profiling
Read Article
Android

Navigation Compose: Modern App Architecture Patterns

Master Navigation Compose for building multi-screen applications. Learn type-safe navigation, handling deep links, bottom navigation integration, and architectural patterns that work seamlessly with Compose's declarative nature.

Dec 1, 2024 11 min read
Navigation Architecture Deep Links
Read Article
Web Dev

Modern Web Performance with Three.js and React

Performance optimization techniques for 3D web applications using Three.js and React, including bundle optimization, lazy loading strategies, and memory management.

Nov 28, 2024 10 min read
Three.js React Performance
Read Article

Code Snippets

Animated Card with Shimmer Effect 
@Composable
fun ShimmerCard(
    isLoading: Boolean = true,
    modifier: Modifier = Modifier,
    content: @Composable () -> Unit = {}
) {
    val shimmerColors = listOf(
        Color.LightGray.copy(alpha = 0.6f),
        Color.LightGray.copy(alpha = 0.2f),
        Color.LightGray.copy(alpha = 0.6f)
    )
    
    val transition = rememberInfiniteTransition()
    val translateAnim = transition.animateFloat(
        initialValue = 0f,
        targetValue = 1000f,
        animationSpec = infiniteRepeatable(
            animation = tween(1000),
            repeatMode = RepeatMode.Reverse
        )
    )
    
    val brush = Brush.linearGradient(
        colors = shimmerColors,
        start = Offset.Zero,
        end = Offset(x = translateAnim.value, y = translateAnim.value)
    )
    
    Card(
        modifier = modifier
            .fillMaxWidth()
            .height(200.dp),
        elevation = CardDefaults.cardElevation(defaultElevation = 8.dp),
        shape = RoundedCornerShape(16.dp)
    ) {
        if (isLoading) {
            Spacer(
                modifier = Modifier
                    .fillMaxSize()
                    .background(brush)
            )
        } else {
            content()
        }
    }
}
Custom Pull-to-Refresh LazyColumn 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun  RefreshableLazyColumn(
    items: List,
    isRefreshing: Boolean,
    onRefresh: () -> Unit,
    modifier: Modifier = Modifier,
    itemContent: @Composable LazyItemScope.(T) -> Unit
) {
    val pullRefreshState = rememberPullRefreshState(
        refreshing = isRefreshing,
        onRefresh = onRefresh
    )
    
    Box(
        modifier = modifier
            .fillMaxSize()
            .pullRefresh(pullRefreshState)
    ) {
        LazyColumn(
            modifier = Modifier.fillMaxSize(),
            contentPadding = PaddingValues(16.dp),
            verticalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            items(items) { item ->
                itemContent(item)
            }
        }
        
        PullRefreshIndicator(
            refreshing = isRefreshing,
            state = pullRefreshState,
            modifier = Modifier.align(Alignment.TopCenter),
            backgroundColor = MaterialTheme.colorScheme.surface,
            contentColor = MaterialTheme.colorScheme.primary
        )
    }
}
Floating Action Button with Menu 
@Composable
fun ExpandableFAB(
    onMainClick: () -> Unit,
    onOption1Click: () -> Unit,
    onOption2Click: () -> Unit,
    onOption3Click: () -> Unit,
    modifier: Modifier = Modifier
) {
    var isExpanded by remember { mutableStateOf(false) }
    val rotationState by animateFloatAsState(
        targetValue = if (isExpanded) 45f else 0f
    )
    
    Column(
        modifier = modifier,
        horizontalAlignment = Alignment.End
    ) {
        // Sub FABs
        AnimatedVisibility(
            visible = isExpanded,
            enter = slideInVertically(
                initialOffsetY = { it },
                animationSpec = tween(300)
            ) + fadeIn(),
            exit = slideOutVertically(
                targetOffsetY = { it },
                animationSpec = tween(300)
            ) + fadeOut()
        ) {
            Column(
                horizontalAlignment = Alignment.End,
                verticalArrangement = Arrangement.spacedBy(16.dp)
            ) {
                SmallFloatingActionButton(
                    onClick = { 
                        onOption3Click()
                        isExpanded = false
                    },
                    containerColor = MaterialTheme.colorScheme.tertiary
                ) {
                    Icon(Icons.Default.Share, "Share")
                }
                
                SmallFloatingActionButton(
                    onClick = { 
                        onOption2Click()
                        isExpanded = false
                    },
                    containerColor = MaterialTheme.colorScheme.secondary
                ) {
                    Icon(Icons.Default.Edit, "Edit")
                }
                
                SmallFloatingActionButton(
                    onClick = { 
                        onOption1Click()
                        isExpanded = false
                    },
                    containerColor = MaterialTheme.colorScheme.primary
                ) {
                    Icon(Icons.Default.Add, "Add")
                }
            }
        }
        
        Spacer(modifier = Modifier.height(16.dp))
        
        // Main FAB
        FloatingActionButton(
            onClick = {
                isExpanded = !isExpanded
                if (!isExpanded) onMainClick()
            }
        ) {
            Icon(
                imageVector = Icons.Default.Add,
                contentDescription = "Menu",
                modifier = Modifier.rotate(rotationState)
            )
        }
    }
}
Custom Bottom Navigation with Badge 
data class BottomNavItem(
    val route: String,
    val icon: ImageVector,
    val label: String,
    val badgeCount: Int = 0
)

@Composable
fun CustomBottomNavigation(
    items: List,
    currentRoute: String,
    onItemClick: (String) -> Unit,
    modifier: Modifier = Modifier
) {
    NavigationBar(
        modifier = modifier,
        containerColor = MaterialTheme.colorScheme.surfaceContainer
    ) {
        items.forEach { item ->
            NavigationBarItem(
                selected = currentRoute == item.route,
                onClick = { onItemClick(item.route) },
                icon = {
                    BadgedBox(
                        badge = {
                            if (item.badgeCount > 0) {
                                Badge(
                                    containerColor = MaterialTheme.colorScheme.error
                                ) {
                                    Text(
                                        text = if (item.badgeCount > 99) "99+" else item.badgeCount.toString(),
                                        style = MaterialTheme.typography.labelSmall
                                    )
                                }
                            }
                        }
                    ) {
                        Icon(
                            imageVector = item.icon,
                            contentDescription = item.label,
                            tint = if (currentRoute == item.route) 
                                MaterialTheme.colorScheme.primary 
                            else 
                                MaterialTheme.colorScheme.onSurfaceVariant
                        )
                    }
                },
                label = {
                    Text(
                        text = item.label,
                        style = MaterialTheme.typography.labelMedium
                    )
                },
                alwaysShowLabel = false
            )
        }
    }
}
Animated Progress Indicator 
@Composable
fun AnimatedProgressIndicator(
    progress: Float,
    modifier: Modifier = Modifier,
    trackColor: Color = MaterialTheme.colorScheme.surfaceVariant,
    progressColor: Color = MaterialTheme.colorScheme.primary,
    strokeWidth: Dp = 8.dp,
    animationDuration: Int = 1000
) {
    val animatedProgress by animateFloatAsState(
        targetValue = progress,
        animationSpec = tween(
            durationMillis = animationDuration,
            easing = FastOutSlowInEasing
        )
    )
    
    Box(
        modifier = modifier.size(120.dp),
        contentAlignment = Alignment.Center
    ) {
        // Background circle
        Canvas(modifier = Modifier.fillMaxSize()) {
            drawCircle(
                color = trackColor,
                radius = size.minDimension / 2 - strokeWidth.toPx() / 2,
                style = Stroke(width = strokeWidth.toPx())
            )
        }
        
        // Progress arc
        Canvas(modifier = Modifier.fillMaxSize()) {
            val sweepAngle = animatedProgress * 360f
            drawArc(
                color = progressColor,
                startAngle = -90f,
                sweepAngle = sweepAngle,
                useCenter = false,
                style = Stroke(
                    width = strokeWidth.toPx(),
                    cap = StrokeCap.Round
                )
            )
        }
        
        // Progress text
        Text(
            text = "${(animatedProgress * 100).toInt()}%",
            style = MaterialTheme.typography.headlineSmall,
            color = MaterialTheme.colorScheme.onSurface
        )
    }
}
Swipe-to-Dismiss Item with Actions 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun  SwipeToDismissItem(
    item: T,
    onDelete: (T) -> Unit,
    onArchive: (T) -> Unit,
    modifier: Modifier = Modifier,
    content: @Composable (T) -> Unit
) {
    val dismissState = rememberDismissState(
        confirmValueChange = { dismissValue ->
            when (dismissValue) {
                DismissValue.DismissedToEnd -> {
                    onArchive(item)
                    true
                }
                DismissValue.DismissedToStart -> {
                    onDelete(item)
                    true
                }
                else -> false
            }
        }
    )
    
    SwipeToDismiss(
        state = dismissState,
        modifier = modifier,
        background = {
            val direction = dismissState.dismissDirection ?: return@SwipeToDismiss
            val color by animateColorAsState(
                when (dismissState.targetValue) {
                    DismissValue.Default -> Color.Transparent
                    DismissValue.DismissedToEnd -> Color.Green
                    DismissValue.DismissedToStart -> Color.Red
                }
            )
            
            val alignment = when (direction) {
                DismissDirection.StartToEnd -> Alignment.CenterStart
                DismissDirection.EndToStart -> Alignment.CenterEnd
            }
            
            val icon = when (direction) {
                DismissDirection.StartToEnd -> Icons.Default.Archive
                DismissDirection.EndToStart -> Icons.Default.Delete
            }
            
            Box(
                Modifier
                    .fillMaxSize()
                    .background(color)
                    .padding(horizontal = 20.dp),
                contentAlignment = alignment
            ) {
                Icon(
                    icon,
                    contentDescription = null,
                    tint = Color.White
                )
            }
        },
        dismissContent = {
            content(item)
        }
    )
}
React Custom Hook for API 
const useApiCall = (url, dependencies = []) => {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        const fetchData = async () => {
            try {
                setLoading(true);
                const response = await fetch(url);
                const result = await response.json();
                setData(result);
            } catch (err) {
                setError(err.message);
            } finally {
                setLoading(false);
            }
        };

        fetchData();
    }, dependencies);

    return { data, loading, error };
};
Three.js Particle System 
class ParticleSystem {
    constructor(scene, count = 1000) {
        this.scene = scene;
        this.particles = [];
        this.init(count);
    }

    init(count) {
        const geometry = new THREE.BufferGeometry();
        const positions = new Float32Array(count * 3);
        
        for (let i = 0; i < count * 3; i += 3) {
            positions[i] = (Math.random() - 0.5) * 100;
            positions[i + 1] = (Math.random() - 0.5) * 100;
            positions[i + 2] = (Math.random() - 0.5) * 100;
        }
        
        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
        
        const material = new THREE.PointsMaterial({
            color: 0x00ff88,
            size: 2
        });
        
        this.particles = new THREE.Points(geometry, material);
        this.scene.add(this.particles);
    }

    animate() {
        this.particles.rotation.x += 0.001;
        this.particles.rotation.y += 0.002;
    }
}
Express.js Middleware 
const express = require('express');
const cors = require('cors');
const app = express();

// Custom authentication middleware
const authenticateToken = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) {
        return res.sendStatus(401);
    }

    jwt.verify(token, process.env.ACCESS_TOKEN_SECRET, (err, user) => {
        if (err) return res.sendStatus(403);
        req.user = user;
        next();
    });
};

// Rate limiting middleware
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100 // limit each IP to 100 requests per windowMs
});

app.use(cors());
app.use(express.json());
app.use(limiter);

app.get('/api/protected', authenticateToken, (req, res) => {
    res.json({ message: 'Access granted', user: req.user });
});
React Context Provider 
const AuthContext = createContext();

export const AuthProvider = ({ children }) => {
    const [user, setUser] = useState(null);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        const unsubscribe = onAuthStateChanged(auth, (user) => {
            setUser(user);
            setLoading(false);
        });

        return unsubscribe;
    }, []);

    const login = async (email, password) => {
        try {
            await signInWithEmailAndPassword(auth, email, password);
        } catch (error) {
            throw new Error(error.message);
        }
    };

    const logout = async () => {
        await signOut(auth);
    };

    const value = {
        user,
        login,
        logout,
        loading
    };

    return (
        <AuthContext.Provider value={value}>
            {!loading && children}
        </AuthContext.Provider>
    );
};
MongoDB Aggregation Pipeline 
const getUserStats = async (userId) => {
    const pipeline = [
        { $match: { userId: new ObjectId(userId) } },
        {
            $group: {
                _id: "$category",
                count: { $sum: 1 },
                totalAmount: { $sum: "$amount" },
                avgAmount: { $avg: "$amount" }
            }
        },
        {
            $project: {
                category: "$_id",
                count: 1,
                totalAmount: { $round: ["$totalAmount", 2] },
                avgAmount: { $round: ["$avgAmount", 2] },
                _id: 0
            }
        },
        { $sort: { totalAmount: -1 } }
    ];

    return await Transaction.aggregate(pipeline);
};
WebSocket Real-time Updates 
const io = require('socket.io')(server);

io.on('connection', (socket) => {
    console.log('User connected:', socket.id);
    
    socket.on('join-room', (roomId) => {
        socket.join(roomId);
        socket.to(roomId).emit('user-joined', socket.id);
    });

    socket.on('send-message', (data) => {
        const { roomId, message, userId } = data;
        
        // Save to database
        saveMessage({ roomId, message, userId, timestamp: new Date() });
        
        // Broadcast to room
        io.to(roomId).emit('receive-message', {
            message,
            userId,
            timestamp: new Date()
        });
    });

    socket.on('disconnect', () => {
        console.log('User disconnected:', socket.id);
    });
});
TensorFlow Image Classifier 
import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np

class ImageClassifier:
    def __init__(self, num_classes, input_shape=(224, 224, 3)):
        self.num_classes = num_classes
        self.input_shape = input_shape
        self.model = self.build_model()
        
    def build_model(self):
        model = models.Sequential([
            layers.Conv2D(32, (3, 3), activation='relu', input_shape=self.input_shape),
            layers.MaxPooling2D((2, 2)),
            layers.Conv2D(64, (3, 3), activation='relu'),
            layers.MaxPooling2D((2, 2)),
            layers.Conv2D(128, (3, 3), activation='relu'),
            layers.MaxPooling2D((2, 2)),
            layers.Flatten(),
            layers.Dense(512, activation='relu'),
            layers.Dropout(0.5),
            layers.Dense(self.num_classes, activation='softmax')
        ])
        
        model.compile(
            optimizer='adam',
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )
        return model
    
    def preprocess_image(self, image_path):
        image = tf.keras.preprocessing.image.load_img(
            image_path, target_size=self.input_shape[:2]
        )
        image_array = tf.keras.preprocessing.image.img_to_array(image)
        image_array = np.expand_dims(image_array, axis=0)
        return image_array / 255.0
    
    def predict(self, image_path):
        processed_image = self.preprocess_image(image_path)
        predictions = self.model.predict(processed_image)
        return predictions[0]
BERT Text Classification 
from transformers import AutoTokenizer, AutoModel
import torch
import torch.nn as nn

class BERTClassifier(nn.Module):
    def __init__(self, model_name='bert-base-uncased', num_classes=2):
        super(BERTClassifier, self).__init__()
        self.bert = AutoModel.from_pretrained(model_name)
        self.dropout = nn.Dropout(0.3)
        self.classifier = nn.Linear(768, num_classes)
        
    def forward(self, input_ids, attention_mask):
        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
        pooled_output = outputs.pooler_output
        output = self.dropout(pooled_output)
        return self.classifier(output)

class TextClassifier:
    def __init__(self, model_path):
        self.tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
        self.model = BERTClassifier()
        self.model.load_state_dict(torch.load(model_path))
        self.model.eval()
        
    def predict(self, text):
        encoding = self.tokenizer(
            text,
            truncation=True,
            padding='max_length',
            max_length=512,
            return_tensors='pt'
        )
        
        with torch.no_grad():
            outputs = self.model(
                encoding['input_ids'], 
                encoding['attention_mask']
            )
            probabilities = torch.nn.functional.softmax(outputs, dim=-1)
            return probabilities.numpy()[0]
OpenCV Face Detection 
import cv2
import numpy as np

class FaceDetector:
    def __init__(self):
        self.face_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
        )
        self.eye_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_eye.xml'
        )
    
    def detect_faces(self, image_path):
        img = cv2.imread(image_path)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        
        faces = self.face_cascade.detectMultiScale(
            gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
        )
        
        results = []
        for (x, y, w, h) in faces:
            face_roi_gray = gray[y:y+h, x:x+w]
            face_roi_color = img[y:y+h, x:x+w]
            
            eyes = self.eye_cascade.detectMultiScale(face_roi_gray)
            
            results.append({
                'face_coords': (x, y, w, h),
                'eyes_count': len(eyes),
                'confidence': self.calculate_confidence(face_roi_gray)
            })
            
            # Draw rectangles
            cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
            for (ex, ey, ew, eh) in eyes:
                cv2.rectangle(face_roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 0), 2)
        
        return img, results
    
    def calculate_confidence(self, face_region):
        # Simple confidence calculation based on contrast
        return cv2.Laplacian(face_region, cv2.CV_64F).var()
Neural Network from Scratch 
import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.layers = layers
        self.weights = []
        self.biases = []
        
        for i in range(len(layers) - 1):
            w = np.random.randn(layers[i], layers[i + 1]) * 0.01
            b = np.zeros((1, layers[i + 1]))
            self.weights.append(w)
            self.biases.append(b)
    
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-np.clip(x, -250, 250)))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)
    
    def forward(self, X):
        self.activations = [X]
        activation = X
        
        for i in range(len(self.weights)):
            z = np.dot(activation, self.weights[i]) + self.biases[i]
            activation = self.sigmoid(z)
            self.activations.append(activation)
        
        return activation
    
    def backward(self, X, y, learning_rate):
        m = X.shape[0]
        
        # Calculate error for output layer
        error = self.activations[-1] - y
        
        # Backpropagate
        for i in range(len(self.weights) - 1, -1, -1):
            delta = error * self.sigmoid_derivative(self.activations[i + 1])
            
            # Update weights and biases
            self.weights[i] -= learning_rate * np.dot(self.activations[i].T, delta) / m
            self.biases[i] -= learning_rate * np.sum(delta, axis=0, keepdims=True) / m
            
            # Calculate error for previous layer
            if i > 0:
                error = np.dot(delta, self.weights[i].T)
    
    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            self.forward(X)
            self.backward(X, y, learning_rate)
            
            if epoch % 100 == 0:
                loss = np.mean((self.activations[-1] - y) ** 2)
                print(f'Epoch {epoch}, Loss: {loss:.4f}')
CSS Grid Layout System 
.grid-container {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
    grid-gap: 2rem;
    padding: 2rem;
}

.grid-item {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    border-radius: 15px;
    padding: 2rem;
    color: white;
    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
    position: relative;
    overflow: hidden;
}

.grid-item::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: linear-gradient(45deg, transparent 30%, rgba(255,255,255,0.1) 50%, transparent 70%);
    transform: translateX(-100%);
    transition: transform 0.6s;
}

.grid-item:hover::before {
    transform: translateX(100%);
}

.grid-item:hover {
    transform: translateY(-10px) scale(1.02);
    box-shadow: 0 20px 40px rgba(0,0,0,0.3);
}
Advanced CSS Animations 
@keyframes morphing {
    0% {
        border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
        background: linear-gradient(45deg, #ff6b6b, #4ecdc4);
    }
    25% {
        border-radius: 30% 60% 70% 40% / 50% 60% 30% 60%;
        background: linear-gradient(45deg, #4ecdc4, #45b7d1);
    }
    50% {
        border-radius: 70% 30% 40% 60% / 40% 70% 60% 30%;
        background: linear-gradient(45deg, #45b7d1, #96ceb4);
    }
    75% {
        border-radius: 40% 70% 60% 30% / 70% 40% 50% 70%;
        background: linear-gradient(45deg, #96ceb4, #ffeaa7);
    }
    100% {
        border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
        background: linear-gradient(45deg, #ffeaa7, #ff6b6b);
    }
}

.morphing-blob {
    width: 200px;
    height: 200px;
    animation: morphing 8s ease-in-out infinite;
    position: relative;
    background: linear-gradient(45deg, #ff6b6b, #4ecdc4);
}

.floating-animation {
    animation: float 6s ease-in-out infinite;
}

@keyframes float {
    0% { transform: translateY(0px) rotate(0deg); }
    33% { transform: translateY(-30px) rotate(120deg); }
    66% { transform: translateY(-20px) rotate(240deg); }
    100% { transform: translateY(0px) rotate(360deg); }
}
Glassmorphism Effect 
.glass-card {
    background: rgba(255, 255, 255, 0.25);
    backdrop-filter: blur(10px);
    -webkit-backdrop-filter: blur(10px);
    border-radius: 20px;
    border: 1px solid rgba(255, 255, 255, 0.18);
    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
    padding: 2rem;
    position: relative;
    overflow: hidden;
}

.glass-card::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: linear-gradient(
        135deg,
        rgba(255, 255, 255, 0.1) 0%,
        rgba(255, 255, 255, 0) 50%,
        rgba(255, 255, 255, 0.1) 100%
    );
    pointer-events: none;
}

.neon-glow {
    color: #00ff88;
    text-shadow: 
        0 0 5px #00ff88,
        0 0 10px #00ff88,
        0 0 15px #00ff88,
        0 0 20px #00ff88,
        0 0 35px #00ff88,
        0 0 40px #00ff88;
    animation: neon-flicker 1.5s infinite alternate;
}

@keyframes neon-flicker {
    0%, 18%, 22%, 25%, 53%, 57%, 100% {
        text-shadow: 
            0 0 5px #00ff88,
            0 0 10px #00ff88,
            0 0 15px #00ff88,
            0 0 20px #00ff88,
            0 0 35px #00ff88,
            0 0 40px #00ff88;
    }
    20%, 24%, 55% {
        text-shadow: none;
    }
}
Responsive Typography 
/* Fluid Typography */
h1 {
    font-size: clamp(2rem, 5vw, 4rem);
    line-height: 1.2;
    font-weight: 700;
}

h2 {
    font-size: clamp(1.5rem, 4vw, 3rem);
    line-height: 1.3;
    font-weight: 600;
}

p {
    font-size: clamp(1rem, 2.5vw, 1.2rem);
    line-height: 1.6;
}

/* Custom Text Selection */
::selection {
    background: linear-gradient(45deg, #00ff88, #0066ff);
    color: white;
    text-shadow: none;
}

/* Gradient Text Effect */
.gradient-text {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
    background-clip: text;
    display: inline-block;
}

/* Text Reveal Animation */
.text-reveal {
    overflow: hidden;
    position: relative;
}

.text-reveal::after {
    content: '';
    position: absolute;
    top: 0;
    right: 0;
    width: 100%;
    height: 100%;
    background: white;
    animation: reveal 2s ease-in-out forwards;
}

@keyframes reveal {
    to {
        width: 0;
    }
}

Let's Work Together

Get In Touch

Currently based in Mumbai, India, and actively seeking opportunities to help and provide services in Mobile development for Android and IOS, Web Development, Custom AI based solutions.

michael.henry.tirkey@gmail.com
Mumbai,India (Remote Available)