Projects & Achievements

Overview

The BDE Voting System digitizes the election workflow for the Student Union. It supports multiple simultaneous polls, student candidacies, and a secure voting process designed to enforce one vote per student.

Development was carried out in a collaborative Git workflow, with careful branch management to integrate contributions from different team members, including the administrative dashboard and poll management modules.

Key Contributions

Authentication and Role Management

The authentication layer, implemented in authentification.php, separates access into three user roles:

• Administrator: creates polls and validates candidate requests.
• Voter: casts exactly one vote per poll.
• Candidate: a voter whose application in demandes_bde has been validated for a specific poll.

PHP session variables were used to preserve security across pages and prevent unauthorized access to the administration dashboard.

Database Modeling and Data Integrity

The MySQL database was structured to protect the election process and keep the data consistent:

• Integrity constraints: foreign keys with ON DELETE CASCADE automatically remove related votes and candidacies when a poll is deleted.
• Repeatable imports: projet.sql was designed with DROP TABLE IF EXISTS statements to support reliable testing and deployment.

Hosting and Deployment

Moving from a local Linux Mint environment to live production was one of the main technical steps in this project:

• Server configuration: config.php was adapted to use InfinityFree remote SQL hosts instead of localhost.
• Data migration: the structure and test data were imported through vPanel and phpMyAdmin, while working around hosting restrictions such as the inability to run manual CREATE DATABASE commands in scripts.
• Production readiness: DNS, paths, and form actions were updated to remain functional in the InfinityFree directory structure.

Collaborative Workflow

This project was built in a team environment on GitHub, so version control discipline was essential:

• Branch management: dedicated branches were used to isolate features before merging into the main branch.
• Conflict resolution: concurrent changes in files such as dashboard.php and projet.sql were resolved manually to preserve functionality.

Live Deployment

The project is fully deployed online and serves as a live demonstration of the system.

• Hosting provider: InfinityFree, using its PHP and MySQL stack for backend execution and database management.
• Security: the website is secured with HTTPS to encrypt credentials and ballot data during transmission.

Live website: votebde.me

Deployment Notes

The final deployment required several technical adjustments:

• pointing the domain to the correct project subdirectory
• exporting the conflict-free version of projet.sql and importing it through the remote database interface
• updating include paths and form action URLs for the InfinityFree environment

Project Overview

This project is a full-stack student management system designed to handle the complete CRUD lifecycle for student records. It combines a responsive interface with a relational database backend so that records can be created, viewed, updated, and deleted in a structured and maintainable way.

Project Goals

• Build a practical web application for managing student data.
• Keep data handling safe by using parameterized database access.
• Deliver a clean interface that remains usable on different screen sizes.
• Organize the project so the frontend and backend responsibilities stay clear.

Tech Stack

• Backend: PHP with PDO
• Database: MySQL
• Frontend: HTML5, CSS3, JavaScript (ES6+)
• Local environment: XAMPP

Key Features

• Secure database access with prepared statements to reduce SQL injection risks.
• Full CRUD operations for maintaining student records.
• Real-time form behavior and validation with JavaScript.
• Structured MySQL schema for storing and retrieving student attributes.
• Responsive layout using CSS grid and flexbox patterns.

Implementation Details

• I used PHP Data Objects (PDO) to keep the database layer consistent and safer to maintain.
• The MySQL schema was organized around core student fields so records could be managed efficiently.
• JavaScript was used to improve the user experience with interactive form feedback and dynamic page behavior.
• CSS was written to keep the interface readable and responsive across different devices.

Development Workflow

1. Defined the data model for student records and identified the fields needed by the application.
2. Built the database layer in PHP and connected it to MySQL using PDO.
3. Implemented the create, read, update, and delete actions for student management.
4. Added JavaScript validation and basic interface interactions to improve usability.
5. Styled the application with a responsive layout and tested the pages in the local XAMPP environment.

Challenges and Solutions

• Data safety: I used prepared statements and PDO to avoid direct string-based SQL handling.
• Maintainability: I separated the responsibilities of the interface, logic, and database access.
• Usability: I improved the form and layout behavior so the system feels more like a real application than a static demo.

Outcome

The result is a functional student management system that demonstrates how a simple full-stack application can combine database design, server-side logic, and responsive frontend behavior into one coherent project.

Project Overview

This project involved designing, configuring, and testing a Samba server on a Linux virtual machine (Ubuntu 24.04) to enable seamless file and printer sharing in a diverse network environment (Linux and Windows clients). Samba is an open-source implementation of the SMB/CIFS protocol, allowing Linux systems to interoperate with Microsoft Windows for resource sharing. The main objective was to implement three different types of file shares with varying levels of security and access control, simulating real-world enterprise file-sharing scenarios.

Project Objectives

• Provide reliable file and printer access to different OS clients.
• Harden shared resources with appropriate permissions and users.
• Document repeatable deployment steps for lab and production use.

Key Activities

• Installed and configured Samba on Ubuntu inside VirtualBox.
• Created user-specific and public shares with correct UNIX permissions.
• Configured printer sharing and verified cross-platform printing.
• Tested connectivity from Windows clients and resolved SMB negotiation issues.

Technical Notes

• Samba configuration: updated /etc/samba/smb.conf with named shares, valid users, and appropriate create mask / directory mask settings.
• User management: synchronized Linux users with Samba (smbpasswd), assigned share-level permissions, and tested with sample accounts.
• Security: limited guest access, used strong file permissions and group-based access control to prevent unauthorized reads/writes.

Lessons Learned

• Cross-OS filename and permission semantics require careful mapping when exposing UNIX files to Windows clients.
• Printer sharing often requires driver and CUPS (Common UNIX Printing System) compatibility checks on the server and client sides.

Results

The lab demonstrates a working Samba server that provides both file and printer services across platforms. Configuration artifacts and notes support re-deployment in other environments. The lab demonstrates a working Samba server that provides both file and printer services across platforms. Configuration artifacts and notes support re-deployment in other environments.

Outcomes

• Implemented the SMB protocol for cross-platform file sharing.
• Implemented three access models: public (anonymous), private (authenticated), and restricted (group + IP-based control).
• Gained proficiency with Samba configuration (/etc/samba/smb.conf), UNIX permissions (chmod, chown), and Samba user management (smbpasswd).
• Verified interoperability between Linux hosts and the Samba server (VM).

Technical Environment

• Hypervisor: Oracle VirtualBox
• Server: Ubuntu 24.04 LTS (VM: 1 vCPU, 1 GB RAM)
• Host OS: Linux Ubuntu
• Network: Adapter 1 = NAT (internet), Adapter 2 = Host-Only (private LAN 192.168.56.0/24)

Project Process & Key Steps

Virtual Machine Setup

• Created and configured an Ubuntu VM with Host-Only networking to simulate an isolated LAN for testing.
• Installed a minimal Ubuntu Server image to conserve resources.

Samba Installation & Basic Configuration

1. Update packages and install Samba:

sudo apt update && sudo apt upgrade -y
sudo apt install -y samba

1. Edit /etc/samba/smb.conf with global parameters (e.g., workgroup, security = user, map to guest = Bad User). Verify with testparm.

Creation of Share Types

Below are the three share models implemented and tested:

• Public Share (open access)
  • Directory: /srv/samba/public
  • Permissions: sudo chown nobody:nogroup /srv/samba/public && sudo chmod 777 /srv/samba/public
  • Samba config: guest ok = yes, writable = yes, force user = nobody
• Private Share (user-authenticated)
  • Directory: /srv/samba/private
  • Create Samba user: sudo smbpasswd -a sambauser
  • Samba config: valid users = sambauser, writable = yes
• Restricted Share (group + IP restrictions)
  • Group: create an admin group (e.g., sudo groupadd admin) and add users.
  • Directory: /srv/samba/restricted with sudo chown root:admin /srv/samba/restricted && sudo chmod 2770 /srv/samba/restricted (setgid).
  • Samba config: valid users = @admin, hosts allow = 192.168.56.1, hosts deny = ALL, browsable = no.

Permissions & Security

• Used create mask and directory mask options to enforce file/directory permissions.
• Implemented hosts allow and hosts deny for IP-level access control.

Testing & Validation

• From the host, tested mounts and access:
  • File manager: smb://192.168.56.101/public
  • Command line: smbclient -L //192.168.56.101 -U sambauser
• Verified operations: list, put, get, mkdir, and deletion where permitted.
• Used testparm and Samba logs (/var/log/samba/) to troubleshoot and verify the configuration.

Skills Demonstrated

• Linux server administration (Ubuntu)
• Samba configuration and troubleshooting
• VirtualBox networking and host-only LAN simulation
• User/group and permission management (chmod, chown, smbpasswd)
• SMB/CIFS protocol understanding and cross-platform interoperability

Challenges & Solutions

• Overcame common Samba issues (protocol negotiation, hosts allow restrictions, permission problems).
• Optimized VM performance with low resources.
• Ensured compatibility between Linux host (client) and Linux VM (server).

Conclusion

This project strengthened practical skills in network file sharing, Linux administration, and cross-platform interoperability—key competencies for systems and network administration roles.