Top 15 Software Engineer Projects 2024 [Source Code]

import nltk
from nltk.chat.util import Chat, reflections

pairs = [
    [
        r"my name is (.*)",
        ["Hello %1, how can I assist you today?"]
    ],
    [
        r"hi|hello|hey",
        ["Hello!", "Hi there!", "Hey! How can I help you?"]
    ],
    [
        r"what can you do?",
        ["I can assist you with a variety of tasks, such as answering questions, providing information, and helping you navigate our services. How may I help you today?"]
    ],
    [
        r"bye|goodbye",
        ["Goodbye! Have a great day.", "Take care! Feel free to reach out if you need any further assistance."]
    ]
]

def chatbot():
    print("Welcome to the AI-Powered Chatbot!")
    chat = Chat(pairs, reflections)
    chat.converse()

if __name__ == "__main__":
    chatbot()

pragma solidity ^0.8.0;

contract SupplyChain {
    struct Product {
        uint256 id;
        string name;
        uint256 price;
        address owner;
        bool delivered;
    }

    mapping(uint256 => Product) public products;
    uint256 public productCount;

    event ProductCreated(uint256 id, string name, uint256 price, address owner);
    event ProductDelivered(uint256 id);

    function createProduct(string memory _name, uint256 _price) public {
        productCount++;
        products[productCount] = Product(productCount, _name, _price, msg.sender, false);
        emit ProductCreated(productCount, _name, _price, msg.sender);
    }

    function deliverProduct(uint256 _id) public {
        require(products[_id].owner == msg.sender, "Only the owner can mark the product as delivered.");
        products[_id].delivered = true;
        emit ProductDelivered(_id);
    }
}

import ARKit
import SceneKit

class ViewController: UIViewController, ARSCNViewDelegate {
    @IBOutlet var sceneView: ARSCNView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        sceneView.delegate = self
        sceneView.showsStatistics = true
        
        let scene = SCNScene()
        sceneView.scene = scene
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        let configuration = ARWorldTrackingConfiguration()
        configuration.planeDetection = .horizontal
        sceneView.session.run(configuration)
    }
    
    func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        if let planeAnchor = anchor as? ARPlaneAnchor {
            let plane = SCNPlane(width: CGFloat(planeAnchor.extent.x), height: CGFloat(planeAnchor.extent.z))
            let planeNode = SCNNode(geometry: plane)
            planeNode.position = SCNVector3(planeAnchor.center.x, 0, planeAnchor.center.z)
            planeNode.eulerAngles.x = -.pi / 2
            node.addChildNode(planeNode)
        }
    }
    
    @IBAction func addFurniture(_ sender: UIButton) {
        let furnitureScene = SCNScene(named: "art.scnassets/chair.scn")!
        let furnitureNode = furnitureScene.rootNode.childNode(withName: "chair", recursively: false)!
        furnitureNode.position = SCNVector3(0, 0, -1)
        sceneView.scene.rootNode.addChildNode(furnitureNode)
    }
}

import speech_recognition as sr
from googletrans import Translator

def translate_speech(language):
    recognizer = sr.Recognizer()
    translator = Translator()

    with sr.Microphone() as source:
        print("Speak now...")
        audio = recognizer.listen(source)

    try:
        text = recognizer.recognize_google(audio)
        print("You said:", text)
        
        translation = translator.translate(text, dest=language)
        print("Translation:", translation.text)
        
    except sr.UnknownValueError:
        print("Sorry, I could not understand your speech.")
    except sr.RequestError:
        print("Sorry, my speech recognition service is currently unavailable.")

# Example usage
translate_speech("fr")  # Translate from default language (English) to French

const express = require('express');
const mqtt = require('mqtt');

const app = express();
const client = mqtt.connect('mqtt://localhost');

// Define routes for controlling devices
app.get('/lights/on', (req, res) => {
  client.publish('home/lights', 'on');
  res.send('Lights turned on');
});

app.get('/lights/off', (req, res) => {
  client.publish('home/lights', 'off');
  res.send('Lights turned off');
});

app.get('/temperature', (req, res) => {
  client.publish('home/temperature/get', '');
  client.subscribe('home/temperature');
  
  client.on('message', (topic, message) => {
    if (topic === 'home/temperature') {
      const temperature = parseFloat(message.toString());
      res.send(`Current temperature: ${temperature}°C`);
    }
  });
});

// Start the server
app.listen(3000, () => {
  console.log('Smart Home Automation System is running on port 3000');
});

from datetime import datetime

class Task:
    def __init__(self, title, description, deadline):
        self.title = title
        self.description = description
        self.deadline = deadline
        self.completed = False
    
    def mark_completed(self):
        self.completed = True
    
    def is_overdue(self):
        return datetime.now() > self.deadline

class TaskManager:
    def __init__(self):
        self.tasks = []
    
    def add_task(self, task):
        self.tasks.append(task)
    
    def remove_task(self, task):
        self.tasks.remove(task)
    
    def get_tasks(self):
        return self.tasks
    
    def get_overdue_tasks(self):
        return [task for task in self.tasks if task.is_overdue()]
    
    def get_completed_tasks(self):
        return [task for task in self.tasks if task.completed]

# Example usage
task_manager = TaskManager()

task1 = Task("Finish project report", "Write the final section and proofread", datetime(2024, 6, 30))
task2 = Task("Submit expense reports", "Gather receipts and fill out expense form", datetime(2024, 7, 15))
task3 = Task("Attend team meeting", "Prepare agenda and discuss project updates", datetime(2024, 7, 10))

task_manager.add_task(task1)
task_manager.add_task(task2)
task_manager.add_task(task3)

print("All tasks:")
for task in task_manager.get_tasks():
    print(task.title)

print("\nOverdue tasks:")
for task in task_manager.get_overdue_tasks():
    print(task.title)

task2.mark_completed()
print("\nCompleted tasks:")
for task in task_manager.get_completed_tasks():
    print(task.title)

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# Load news articles data
articles_df = pd.read_csv('news_articles.csv')

# Create TF-IDF matrix
tfidf = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf.fit_transform(articles_df['content'])

# Function to get article recommendations
def get_recommendations(article_id, top_n=5):
    # Get the index of the article
    idx = articles_df[articles_df['article_id'] == article_id].index[0]
    
    # Calculate cosine similarity scores
    similarity_scores = cosine_similarity(tfidf_matrix[idx], tfidf_matrix)
    
    # Get the indices of top similar articles
    similar_indices = similarity_scores.argsort()[0][-top_n-1:-1][::-1]
    
    # Return the titles of recommended articles
    return articles_df.iloc[similar_indices]['title'].tolist()

# Example usage
article_id = 1001  # ID of the article for which recommendations are needed
recommended_articles = get_recommendations(article_id)

print(f"Recommended articles for article {article_id}:")
for article in recommended_articles:
    print(article)

import tweepy
from textblob import TextBlob

# Twitter API credentials
consumer_key = 'YOUR_CONSUMER_KEY'
consumer_secret = 'YOUR_CONSUMER_SECRET'
access_token = 'YOUR_ACCESS_TOKEN'
access_token_secret = 'YOUR_ACCESS_TOKEN_SECRET'

# Authenticate with Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

# Function to perform sentiment analysis on tweets
def analyze_sentiment(tweet):
    analysis = TextBlob(tweet.text)
    sentiment = analysis.sentiment.polarity
    
    if sentiment > 0:
        return 'Positive'
    elif sentiment < 0:
        return 'Negative'
    else:
        return 'Neutral'

# Search for tweets containing a specific keyword
keyword = 'OpenAI'
tweets = tweepy.Cursor(api.search_tweets, q=keyword, lang='en').items(100)

# Analyze sentiment of each tweet
sentiment_counts = {'Positive': 0, 'Negative': 0, 'Neutral': 0}
for tweet in tweets:
    sentiment = analyze_sentiment(tweet)
    sentiment_counts[sentiment] += 1

# Print sentiment analysis results
print(f"Sentiment analysis for '{keyword}':")
for sentiment, count in sentiment_counts.items():
    print(f"{sentiment}: {count} tweets")

using UnityEngine;
using UnityEngine.XR;

public class VRFitnessApp : MonoBehaviour
{
    public Transform headTransform;
    public Transform leftHandTransform;
    public Transform rightHandTransform;

    private Vector3 initialHeadPosition;
    private bool isWorkoutStarted = false;
    private float workoutDuration = 0f;

    private void Start()
    {
        // Initialize the initial head position
        initialHeadPosition = headTransform.position;
    }

    private void Update()
    {
        // Check if the user has started the workout
        if (!isWorkoutStarted && IsUserReady())
        {
            StartWorkout();
        }

        // Update the workout duration if the workout is in progress
        if (isWorkoutStarted)
        {
            workoutDuration += Time.deltaTime;
        }

        // Check if the user has completed the workout
        if (isWorkoutStarted && IsWorkoutComplete())
        {
            EndWorkout();
        }
    }

    private bool IsUserReady()
    {
        // Check if the user's head and hands are in the starting position
        return headTransform.position.y >= initialHeadPosition.y &&
               leftHandTransform.position.y >= initialHeadPosition.y &&
               rightHandTransform.position.y >= initialHeadPosition.y;
    }

    private void StartWorkout()
    {
        isWorkoutStarted = true;
        workoutDuration = 0f;
        Debug.Log("Workout started!");
    }

    private bool IsWorkoutComplete()
    {
        // Check if the workout duration has reached the desired time
        return workoutDuration >= 60f; // Example: 60 seconds workout
    }

    private void EndWorkout()
    {
        isWorkoutStarted = false;
        Debug.Log("Workout completed! Duration: " + workoutDuration + " seconds");
    }
}

from flask import Flask, jsonify
from random import randint

app = Flask(__name__)

# Simulated waste bin data
waste_bins = [
    {'id': 1, 'location': 'Main Street', 'fill_level': 0.4},
    {'id': 2, 'location': 'Park Avenue', 'fill_level': 0.8},
    {'id': 3, 'location': 'Broadway', 'fill_level': 0.6},
    # Add more waste bins...
]

# Route to get waste bin data
@app.route('/waste-bins', methods=['GET'])
def get_waste_bins():
    return jsonify(waste_bins)

# Route to update waste bin fill level (simulated)
@app.route('/waste-bins/<int:bin_id>/update', methods=['POST'])
def update_waste_bin(bin_id):
    for waste_bin in waste_bins:
        if waste_bin['id'] == bin_id:
            waste_bin['fill_level'] = randint(1, 100) / 100
            return jsonify(waste_bin)
    return jsonify({'error': 'Waste bin not found'}), 404

if __name__ == '__main__':
    app.run()

import pandas as pd
from sklearn.ensemble import IsolationForest

# Load network traffic data
data = pd.read_csv('network_traffic.csv')

# Select relevant features for anomaly detection
features = ['src_ip', 'dst_ip', 'src_port', 'dst_port', 'protocol', 'bytes']

# Train isolation forest model for anomaly detection
model = IsolationForest(n_estimators=100, contamination=0.01)
model.fit(data[features])

# Function to detect anomalies in network traffic
def detect_anomalies(traffic_data):
    anomalies = model.predict(traffic_data[features])
    anomaly_indices = list(anomalies).index(-1)
    return traffic_data.iloc[anomaly_indices]

# Example usage
new_traffic_data = pd.read_csv('new_traffic.csv')
anomalies = detect_anomalies(new_traffic_data)

print("Detected anomalies:")
print(anomalies)

import speech_recognition as sr
import pyttsx3
import pywhatkit

# Initialize speech recognition and text-to-speech engines
recognizer = sr.Recognizer()
engine = pyttsx3.init()

# Function to convert speech to text
def speech_to_text():
    with sr.Microphone() as source:
        print("Listening...")
        audio = recognizer.listen(source)
    try:
        text = recognizer.recognize_google(audio)
        print("You said:", text)
        return text
    except sr.UnknownValueError:
        print("Sorry, I could not understand your speech.")
    except sr.RequestError:
        print("Sorry, my speech recognition service is currently unavailable.")

# Function to convert text to speech
def text_to_speech(text):
    engine.say(text)
    engine.runAndWait()

# Function to handle user commands
def handle_command(command):
    if 'search' in command:
        query = command.replace('search', '')
        pywhatkit.search(query)
        text_to_speech(f"Searching for {query} on Google.")
    elif 'play' in command:
        video = command.replace('play', '')
        pywhatkit.playonyt(video)
        text_to_speech(f"Playing {video} on YouTube.")
    else:
        text_to_speech("Sorry, I could not understand your command.")

# Main loop
while True:
    command = speech_to_text()
    if command:
        handle_command(command)

import ARKit
import CoreLocation
import MapKit

class ViewController: UIViewController, ARSCNViewDelegate, CLLocationManagerDelegate {
    @IBOutlet var sceneView: ARSCNView!
    
    let locationManager = CLLocationManager()
    var currentLocation: CLLocation?
    var destination: CLLocation?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        sceneView.delegate = self
        
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
        locationManager.requestWhenInUseAuthorization()
        locationManager.startUpdatingLocation()
    }
    
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.last else { return }
        currentLocation = location
    }
    
    func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        guard let currentLocation = currentLocation, let destination = destination else { return }
        
        let distance = currentLocation.distance(from: destination)
        let direction = currentLocation.direction(to: destination)
        
        let textNode = SCNNode()
        textNode.geometry = SCNText(string: "\(distance) meters", extrusionDepth: 1.0)
        textNode.scale = SCNVector3(0.01, 0.01, 0.01)
        textNode.position = SCNVector3(0, 0, -1)
        node.addChildNode(textNode)
        
        let arrowNode = SCNNode()
        arrowNode.geometry = SCNPyramid(width: 0.1, height: 0.2, length: 0.1)
        arrowNode.position = SCNVector3(0, 0, -1)
        arrowNode.eulerAngles.y = direction
        node.addChildNode(arrowNode)
    }
}

extension CLLocation {
    func distance(from location: CLLocation) -> CLLocationDistance {
        return distance(from: location)
    }
    
    func direction(to location: CLLocation) -> Double {
        return atan2(location.coordinate.longitude - coordinate.longitude,
                     location.coordinate.latitude - coordinate.latitude)
    }
}

import cv2
import numpy as np

# Load pre-trained object detection model (e.g., YOLO)
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")

# Load class labels
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# Set video capture source (e.g., camera or video file)
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    
    # Perform object detection
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True, crop=False)
    net.setInput(blob)
    outputs = net.forward(net.getUnconnectedOutLayersNames())
    
    # Process detection results
    for output in outputs:
        for detection in output:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            
            if confidence > 0.5:
                center_x = int(detection[0] * frame.shape[1])
                center_y = int(detection[1] * frame.shape[0])
                width = int(detection[2] * frame.shape[1])
                height = int(detection[3] * frame.shape[0])
                
                left = int(center_x - width / 2)
                top = int(center_y - height / 2)
                
                cv2.rectangle(frame, (left, top), (left + width, top + height), (0, 255, 0), 2)
                cv2.putText(frame, classes[class_id], (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    
    cv2.imshow("Object Detection", frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Load equipment sensor data
data = pd.read_csv('equipment_data.csv')

# Prepare features and target variable
features = ['sensor1', 'sensor2', 'sensor3', 'operating_hours']
target = 'failure'

X = data[features]
y = data[target]

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a random forest classifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Function to predict equipment failure
def predict_failure(sensor_data):
    prediction = model.predict(sensor_data)
    return prediction[0]

# Example usage
new_sensor_data = pd.DataFrame({
    'sensor1': [100],
    'sensor2': [80],
    'sensor3': [90],
    'operating_hours': [5000]
})

failure_prediction = predict_failure(new_sensor_data)

if failure_prediction:
    print("Equipment is likely to fail. Schedule maintenance.")
else:
    print("Equipment is operating normally.")