Getiye Demis Portifolio

CS Student

Hi there, welcome! I'm Getiye Demis Full-Stack Developer Computer Science Student @ Debre Berhan University
focused on building modern, responsive, and scalable web applications. I enjoy turning ideas into real digital solutions by combining creative front-end design with efficient back-end development through academic learning and hands-on projects.

I continuously strengthen my programming, problem-solving, and software development skills. I am passionate about learning new technologies, improving my development practices, and building applications that solve real-world problems and create meaningful digital experiences. Building applications that solve real-world problems and create meaningful digital experiences.

Hire Me View Work View Resume

My Skills

Technologies and tools I work with from front-end finesse to back-end logic — the technologies I use to bring ideas to life

Front-end

HTML5 95%

CSS3 90%

JavaScript 85%

React 80%

Back-end

Python 85%

Java 80%

C++ 75%

Node.js 80%

PHP 75%

Databases

MySQL 85%

MongoDB 80%

Oracle 75%

SQL Server 80%

Tools

VS Code 95%

Git 90%

GitHub 90%

Canva 85%

Projects

Employee Payroll Management System

Employee Payroll Management

Java-based system to manage employee payroll information and generate payslips efficiently.

Cafe Management System

Cafe Management System

Web application using HTML, CSS, JS, and MySQL for managing customer orders and operations.

Personal Portfolio Website

Personal Portfolio

Modern responsive portfolio website showcasing skills, projects, and contact info.

Explore All My Projects on GitHub

Want to see more of my work? Check out my GitHub profile where I share all my coding projects, from small experiments to full-stack applications. Feel free to explore, star, or even contribute!

Visit My GitHub Profile

⭐ Don't forget to star your favorite projects!

// code samples

Code Snippets from Projects

Thread Pool in Modern C++

Concurrent task processing with worker threads

C++ Advanced

Efficient thread pool implementation for parallel task execution using modern C++ features.

ThreadPool.cpp

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;

public:
    ThreadPool(size_t threads) : stop(false) {
        for(size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while(true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock, [this] {
                            return this->stop || !this->tasks.empty();
                        });
                        if(this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for(std::thread &worker: workers) {
            worker.join();
        }
    }
};

#Multithreading #Concurrency #ModernC++ #Performance

Student Management System - Core Logic

CRUD operations with grade calculation

JavaScript Intermediate

Complete student management with grade calculation and performance tracking.

StudentManager.js

class StudentManager {
    constructor() {
        this.students = new Map();
        this.grades = new Map();
    }

    addStudent(studentData) {
        const student = {
            id: studentData.id || Date.now(),
            name: studentData.name,
            age: studentData.age,
            grade: studentData.grade,
            email: studentData.email,
            enrollmentDate: new Date()
        };
        
        this.students.set(student.id, student);
        this.grades.set(student.id, []);
        return student;
    }

    addGrade(studentId, subject, score) {
        if (!this.students.has(studentId)) {
            throw new Error('Student not found');
        }
        
        const gradeEntry = {
            subject: subject,
            score: score,
            date: new Date(),
            letterGrade: this.calculateLetterGrade(score)
        };
        
        const studentGrades = this.grades.get(studentId) || [];
        studentGrades.push(gradeEntry);
        this.grades.set(studentId, studentGrades);
        
        return gradeEntry;
    }

    calculateLetterGrade(score) {
        if (score >= 90) return 'A';
        if (score >= 80) return 'B';
        if (score >= 70) return 'C';
        if (score >= 60) return 'D';
        return 'F';
    }

    getStudentGPA(studentId) {
        const studentGrades = this.grades.get(studentId);
        if (!studentGrades || studentGrades.length === 0) return 0;
        
        const total = studentGrades.reduce((sum, grade) => {
            return sum + this.gradeToPoints(grade.letterGrade);
        }, 0);
        
        return (total / studentGrades.length).toFixed(2);
    }

    gradeToPoints(letterGrade) {
        const points = {
            'A': 4.0, 'B': 3.0, 'C': 2.0, 'D': 1.0, 'F': 0.0
        };
        return points[letterGrade] || 0;
    }
}

#CRUD #Map #Education #Logic

Employee Payroll Management System

Complete payroll calculation with tax & allowances

Java Enterprise

Full-featured payroll system with employee management, salary calculation, tax deductions, and payslip generation.

PayrollCalculator.java

import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

// Employee Class
class Employee {
    private static final AtomicLong idGenerator = new AtomicLong(1000);
    private final long employeeId;
    private String firstName;
    private String lastName;
    private double monthlySalary;
    private LocalDate hireDate;
    private List<Attendance> attendanceRecords;
    private List<Benefit> benefits;

    public enum EmploymentType {
        FULL_TIME, PART_TIME, CONTRACT
    }
    private EmploymentType employmentType;

    public Employee(String firstName, String lastName, double monthlySalary, EmploymentType type) {
        this.employeeId = idGenerator.getAndIncrement();
        this.firstName = firstName;
        this.lastName = lastName;
        this.monthlySalary = monthlySalary;
        this.employmentType = type;
        this.hireDate = LocalDate.now();
        this.attendanceRecords = new ArrayList<>();
        this.benefits = new ArrayList<>();
    }

    public long getEmployeeId() { return employeeId; }
    public String getFullName() { return firstName + " " + lastName; }
    public double getMonthlySalary() { return monthlySalary; }
    public void addAttendance(Attendance attendance) { attendanceRecords.add(attendance); }
    public List<Attendance> getAttendanceRecords() { return attendanceRecords; }
    public void addBenefit(Benefit benefit) { benefits.add(benefit); }
    public List<Benefit> getBenefits() { return benefits; }
}

// Attendance Class
class Attendance {
    private LocalDate date;
    private double hoursWorked;
    
    public Attendance(LocalDate date, double hoursWorked) {
        this.date = date;
        this.hoursWorked = hoursWorked;
    }
    
    public double getHoursWorked() { return hoursWorked; }
}

// Benefit Class
class Benefit {
    private String name;
    private double amount;
    private BenefitType type;
    
    public enum BenefitType {
        ALLOWANCE, DEDUCTION
    }
    
    public Benefit(String name, double amount, BenefitType type) {
        this.name = name;
        this.amount = amount;
        this.type = type;
    }
    
    public double getAmount() { return amount; }
    public BenefitType getType() { return type; }
}

// Tax Calculator
class TaxCalculator {
    private static final double TAX_FREE_THRESHOLD = 60000;
    private static final double SOCIAL_SECURITY_RATE = 0.07;
    private static final double PENSION_RATE = 0.11;
    
    private static final TaxBracket[] TAX_BRACKETS = {
        new TaxBracket(0, 6000, 0.0),
        new TaxBracket(6001, 20000, 0.10),
        new TaxBracket(20001, 40000, 0.15),
        new TaxBracket(40001, 60000, 0.20),
        new TaxBracket(60001, 100000, 0.25),
        new TaxBracket(100001, Double.MAX_VALUE, 0.30)
    };
    
    static class TaxBracket {
        double lower; double upper; double rate;
        TaxBracket(double l, double u, double r) { lower = l; upper = u; rate = r; }
    }
    
    public static TaxResult calculateTax(double monthlyGross) {
        double annualGross = monthlyGross * 12;
        double annualTax = 0;
        double remaining = annualGross;
        
        for (TaxBracket b : TAX_BRACKETS) {
            if (remaining <= 0) break;
            double taxable = Math.min(remaining, b.upper - b.lower);
            annualTax += taxable * b.rate;
            remaining -= taxable;
        }
        
        double monthlyTax = annualTax / 12;
        double socialSecurity = monthlyGross * SOCIAL_SECURITY_RATE;
        double pension = monthlyGross * PENSION_RATE;
        double netSalary = monthlyGross - monthlyTax - socialSecurity - pension;
        
        return new TaxResult(monthlyTax, socialSecurity, pension, netSalary);
    }
}

class TaxResult {
    double incomeTax; double socialSecurity; double pension; double netSalary;
    TaxResult(double it, double ss, double p, double ns) {
        incomeTax = it; socialSecurity = ss; pension = p; netSalary = ns;
    }
}

// Payslip Class
class Payslip {
    private Employee employee;
    private LocalDate payPeriod;
    private double grossSalary;
    private double netSalary;
    private TaxResult taxResult;
    private List<Benefit> allowances = new ArrayList<>();
    private List<Benefit> deductions = new ArrayList<>();
    
    public Payslip(Employee emp, LocalDate period) {
        this.employee = emp;
        this.payPeriod = period;
    }
    
    public void calculate() {
        // Calculate base salary from attendance
        double totalHours = employee.getAttendanceRecords().stream()
            .filter(a -> a.getDate().getMonth() == payPeriod.getMonth())
            .mapToDouble(Attendance::getHoursWorked)
            .sum();
        
        double hourlyRate = employee.getMonthlySalary() / 160;
        double basePay = totalHours * hourlyRate;
        
        // Add allowances
        double allowanceTotal = employee.getBenefits().stream()
            .filter(b -> b.getType() == Benefit.BenefitType.ALLOWANCE)
            .mapToDouble(Benefit::getAmount)
            .sum();
        
        // Subtract deductions
        double deductionTotal = employee.getBenefits().stream()
            .filter(b -> b.getType() == Benefit.BenefitType.DEDUCTION)
            .mapToDouble(Benefit::getAmount)
            .sum();
        
        this.grossSalary = basePay + allowanceTotal;
        this.taxResult = TaxCalculator.calculateTax(grossSalary);
        this.netSalary = taxResult.netSalary - deductionTotal;
    }
    
    public void printPayslip() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("           EMPLOYEE PAYSLIP");
        System.out.println("=".repeat(60));
        System.out.println("Employee: " + employee.getFullName());
        System.out.println("Period: " + payPeriod.getMonth() + " " + payPeriod.getYear());
        System.out.println("-".repeat(60));
        System.out.printf("Gross Salary: $%.2f\n", grossSalary);
        System.out.printf("Income Tax: $%.2f\n", taxResult.incomeTax);
        System.out.printf("Social Security: $%.2f\n", taxResult.socialSecurity);
        System.out.printf("Pension: $%.2f\n", taxResult.pension);
        System.out.println("-".repeat(60));
        System.out.printf("NET SALARY: $%.2f\n", netSalary);
        System.out.println("=".repeat(60));
    }
}

// Main Payroll Processor
public class PayrollCalculator {
    public static void main(String[] args) {
        System.out.println("=".repeat(60));
        System.out.println("   EMPLOYEE PAYROLL SYSTEM");
        System.out.println("=".repeat(60));
        
        // Create employee
        Employee emp = new Employee("John", "Smith", 85000, 
            Employee.EmploymentType.FULL_TIME);
        
        // Add attendance
        for (int day = 1; day <= 22; day++) {
            emp.addAttendance(new Attendance(
                LocalDate.now().withDayOfMonth(day), 8.5));
        }
        
        // Add benefits
        emp.addBenefit(new Benefit("Transport", 1500, Benefit.BenefitType.ALLOWANCE));
        emp.addBenefit(new Benefit("Lunch", 800, Benefit.BenefitType.ALLOWANCE));
        emp.addBenefit(new Benefit("Health Insurance", 2000, Benefit.BenefitType.DEDUCTION));
        
        // Generate payslip
        Payslip payslip = new Payslip(emp, LocalDate.now());
        payslip.calculate();
        payslip.printPayslip();
    }
}

#OOP #Inheritance #Polymorphism #Encapsulation #Payroll #Tax Calculation

HTML5 - Semantic Layout Structure

Modern web page structure for beginners

HTML Beginner Friendly

Clean, semantic HTML5 structure that every beginner should know for proper web page layout.

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My First Web Page</title>
    <meta name="description" content="A beginner-friendly HTML template">
</head>
<body>
    <!-- Header Section -->
    <header>
        <h1>Welcome to My Website</h1>
        <nav>
            <ul>
                <li><a href="#home">Home</a></li>
                <li><a href="#about">About</a></li>
                <li><a href="#services">Services</a></li>
                <li><a href="#contact">Contact</a></li>
            </ul>
        </nav>
    </header>

    <!-- Main Content -->
    <main>
        <section id="about">
            <h2>About Us</h2>
            <article>
                <h3>Our Story</h3>
                <p>We are passionate about creating amazing web experiences.</p>
                <img src="about-image.jpg" alt="About us" width="300">
            </article>
        </section>

        <section id="services">
            <h2>Our Services</h2>
            <div class="service-grid">
                <div class="service-card">
                    <h3>Web Design</h3>
                    <p>Beautiful, responsive designs</p>
                </div>
                <div class="service-card">
                    <h3>Development</h3>
                    <p>Clean, efficient code</p>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer Section -->
    <footer>
        <p>&copy; 2024 My Website. All rights reserved.</p>
        <div class="social-links">
            <a href="#">Facebook</a> |
            <a href="#">Twitter</a> |
            <a href="#">Instagram</a>
        </div>
    </footer>
</body>
</html>

#SemanticHTML #SEO #Accessibility #Beginner

CSS Flexbox & Grid Layouts

Modern responsive layouts for beginners

CSS Beginner Friendly

Essential CSS layouts using Flexbox and Grid for responsive web design.

styles.css

/* CSS Variables for easy theming */
:root {
    --primary-color: #3498db;
    --secondary-color: #2ecc71;
    --text-color: #333;
    --bg-light: #f9f9f9;
    --spacing: 1rem;
}

/* Reset & Base Styles */
* {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
}

body {
    font-family: 'Arial', sans-serif;
    line-height: 1.6;
    color: var(--text-color);
}

/* Flexbox Navigation */
.navbar {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 1rem 2rem;
    background: var(--primary-color);
}

.nav-links {
    display: flex;
    gap: 2rem;
    list-style: none;
}

.nav-links a {
    color: white;
    text-decoration: none;
    transition: opacity 0.3s;
}

.nav-links a:hover {
    opacity: 0.8;
}

/* CSS Grid Layout */
.projects-grid {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
    gap: 2rem;
    padding: 2rem;
}

.project-card {
    background: white;
    border-radius: 8px;
    padding: 1.5rem;
    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
    transition: transform 0.3s, box-shadow 0.3s;
}

.project-card:hover {
    transform: translateY(-5px);
    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
}

/* Responsive Design */
@media (max-width: 768px) {
    .navbar {
        flex-direction: column;
        gap: 1rem;
    }
    
    .nav-links {
        flex-direction: column;
        text-align: center;
        gap: 1rem;
    }
    
    .projects-grid {
        grid-template-columns: 1fr;
    }
}

/* Animations */
@keyframes fadeIn {
    from { opacity: 0; transform: translateY(20px); }
    to { opacity: 1; transform: translateY(0); }
}

.fade-in {
    animation: fadeIn 0.6s ease forwards;
}

#Flexbox #Grid #Responsive #Animations

JavaScript DOM Manipulation

Interactive web features for beginners

JavaScript Beginner Friendly

Learn how to make your website interactive with DOM manipulation.

script.js

// Wait for DOM to load
document.addEventListener('DOMContentLoaded', () => {
    
    // Element Selection
    const header = document.querySelector('header');
    const buttons = document.querySelectorAll('.btn');
    const form = document.getElementById('contactForm');
    
    // Event Listeners
    buttons.forEach(button => {
        button.addEventListener('click', handleButtonClick);
    });
    
    function handleButtonClick(event) {
        const button = event.target;
        console.log('Button clicked:', button.textContent);
        
        // Toggle class
        button.classList.toggle('active');
        
        // Change content
        button.textContent = button.classList.contains('active') 
            ? 'Active' 
            : 'Inactive';
    }
    
    // Form Validation
    if (form) {
        form.addEventListener('submit', (e) => {
            e.preventDefault();
            
            const name = document.getElementById('name').value;
            const email = document.getElementById('email').value;
            
            if (!name || !email) {
                showError('Please fill all fields');
                return;
            }
            
            if (!isValidEmail(email)) {
                showError('Please enter a valid email');
                return;
            }
            
            submitForm({ name, email });
        });
    }
    
    // Helper Functions
    function isValidEmail(email) {
        return email.includes('@') && email.includes('.');
    }
    
    function showError(message) {
        const errorDiv = document.createElement('div');
        errorDiv.className = 'error-message';
        errorDiv.textContent = message;
        
        document.body.prepend(errorDiv);
        
        setTimeout(() => {
            errorDiv.remove();
        }, 3000);
    }
    
    function submitForm(data) {
        console.log('Form submitted:', data);
        alert('Form submitted successfully!');
    }
    
    // Dynamic Content Creation
    function createCard(title, description) {
        const card = document.createElement('div');
        card.className = 'card';
        
        card.innerHTML = `
            ${title}
            ${description}
            
        `;
        
        return card;
    }
    
    // Append multiple cards
    const container = document.querySelector('.cards-container');
    if (container) {
        const projects = [
            { title: 'Project 1', desc: 'Description 1' },
            { title: 'Project 2', desc: 'Description 2' },
            { title: 'Project 3', desc: 'Description 3' }
        ];
        
        projects.forEach(proj => {
            container.appendChild(createCard(proj.title, proj.desc));
        });
    }
});

#DOM #Events #Forms #Interactive

Python - To-Do List CLI App

Command-line application for beginners

Python Beginner Friendly

Simple but practical to-do list application to learn Python basics.

todo.py

import json
import os
from datetime import datetime

class TodoList:
    def __init__(self, filename='tasks.json'):
        self.filename = filename
        self.tasks = self.load_tasks()
    
    def load_tasks(self):
        """Load tasks from file"""
        if os.path.exists(self.filename):
            with open(self.filename, 'r') as file:
                return json.load(file)
        return []
    
    def save_tasks(self):
        """Save tasks to file"""
        with open(self.filename, 'w') as file:
            json.dump(self.tasks, file, indent=2)
    
    def add_task(self, title, priority='medium'):
        """Add a new task"""
        task = {
            'id': len(self.tasks) + 1,
            'title': title,
            'priority': priority,
            'completed': False,
            'created_at': datetime.now().isoformat(),
            'completed_at': None
        }
        self.tasks.append(task)
        self.save_tasks()
        print(f"✅ Task added: {title}")
    
    def list_tasks(self, show_completed=False):
        """Display all tasks"""
        if not self.tasks:
            print("📝 No tasks found!")
            return
        
        print("\n" + "="*50)
        print("YOUR TO-DO LIST")
        print("="*50)
        
        for task in self.tasks:
            if task['completed'] and not show_completed:
                continue
                
            status = "✅" if task['completed'] else "⭕"
            priority_mark = {
                'high': '🔴',
                'medium': '🟡',
                'low': '🟢'
            }.get(task['priority'], '⚪')
            
            print(f"{status} [{priority_mark}] #{task['id']}: {task['title']}")
            
            if task['completed'] and task['completed_at']:
                print(f"   Completed: {task['completed_at'][:10]}")
    
    def complete_task(self, task_id):
        """Mark task as completed"""
        for task in self.tasks:
            if task['id'] == task_id:
                task['completed'] = True
                task['completed_at'] = datetime.now().isoformat()
                self.save_tasks()
                print(f"✅ Task #{task_id} completed!")
                return
        
        print(f"❌ Task #{task_id} not found!")
    
    def delete_task(self, task_id):
        """Delete a task"""
        initial_count = len(self.tasks)
        self.tasks = [t for t in self.tasks if t['id'] != task_id]
        
        if len(self.tasks) < initial_count:
            self.save_tasks()
            print(f"🗑️ Task #{task_id} deleted!")
        else:
            print(f"❌ Task #{task_id} not found!")
    
    def get_statistics(self):
        """Show task statistics"""
        total = len(self.tasks)
        completed = sum(1 for t in self.tasks if t['completed'])
        pending = total - completed
        
        print("\n📊 STATISTICS")
        print(f"Total tasks: {total}")
        print(f"Completed: {completed}")
        print(f"Pending: {pending}")
        print(f"Progress: {completed/total*100:.1f}%" if total > 0 else "No tasks")

# Main program
def main():
    todo = TodoList()
    
    while True:
        print("\n" + "="*50)
        print("📝 TO-DO LIST APPLICATION")
        print("="*50)
        print("1. Add Task")
        print("2. List Tasks")
        print("3. Complete Task")
        print("4. Delete Task")
        print("5. Show Statistics")
        print("6. Exit")
        
        choice = input("\nEnter your choice (1-6): ").strip()
        
        if choice == '1':
            title = input("Task title: ")
            priority = input("Priority (high/medium/low) [medium]: ") or 'medium'
            todo.add_task(title, priority)
        
        elif choice == '2':
            show_all = input("Show completed tasks? (y/n): ").lower() == 'y'
            todo.list_tasks(show_all)
        
        elif choice == '3':
            try:
                task_id = int(input("Task ID to complete: "))
                todo.complete_task(task_id)
            except ValueError:
                print("❌ Please enter a valid number!")
        
        elif choice == '4':
            try:
                task_id = int(input("Task ID to delete: "))
                todo.delete_task(task_id)
            except ValueError:
                print("❌ Please enter a valid number!")
        
        elif choice == '5':
            todo.get_statistics()
        
        elif choice == '6':
            print("👋 Goodbye!")
            break
        
        else:
            print("❌ Invalid choice!")

if __name__ == "__main__":
    main()

#CLI #FileIO #JSON #Beginner

Evolution & Growth

Every expert was once a beginner — my path from first "Hello World" to building full-stack applications, transforming curiosity into code and challenges into growth along the way

1

The Beginning

Started from absolute zero at Debre Birhan University, where I wrote my first lines of code and discovered the magic of turning logic into working programs. Those early days of debugging and late-night problem-solving shaped my entire approach to development.

C++PythonJavaJavaScript

Read my full story →

2

Building Real Things

Moved beyond endless tutorials and started building actual projects that solved real problems. The thrill of seeing my first web app come to life — even with its bugs and imperfections — taught me more than any course ever could.

ReactNode.jsPHPBootstrap

See how I learned →

3

From Local to Live

First projects deployed to the cloud — that's when I learned that real users have zero tolerance for bugs, slow loading times, or confusing interfaces. Every crash and user complaint became a valuable lesson in resilience and user-centered design.

DeploymentProject MgmtEnd-to-End

Explore my journey →

4

Thinking Like a Pro

Started caring deeply about both form and function — crafting elegant front-end experiences while ensuring the back-end could handle real-world demands. This is where I learned that great code isn't just about working, it's about being maintainable, scalable, and a joy to build upon.

UI/UXAPI DesignDatabases

Read more →

5

Beyond Code

Discovered that the best developers aren't just coding machines — they're collaborators, communicators, and creative problem-solvers. Learning to explain complex ideas simply, work in teams, and understand client needs transformed me from a coder into a developer.

TeamworkCommunicationProblem-Solving

Learn more →

6

What's Next

Building bigger, building smarter — now I'm focused on creating applications that don't just function, but genuinely improve people's lives. My goal is to combine technical excellence with meaningful impact, one project at a time.

InnovationScalabilityBest Practices

See my vision →

📖 Want to read the full story behind my journey? Click the button below to see my complete learning experience in detail.

Contact Me

Get in Touch

Email getiyedemis17@gmail.com

Phone +251 906902551

Location Debre Birhan, Ethiopia