DEV Community: Suleiman Alhaji Mohammed

FlashFeed AI News Summarizer

Suleiman Alhaji Mohammed — Mon, 11 Aug 2025 02:33:49 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

I built FlashFeed AI News Summarizer, a Node.js application that fetches the latest news headlines from multiple RSS feeds (including NYTimes World and BBC World), summarizes the news using Hugging Face’s state-of-the-art BART summarization model, and caches the summarized news in Redis. This ensures fast and efficient retrieval of concise, AI-generated summaries for each news article. The app exposes a REST API endpoint /news that returns fresh, summarized news in JSON format.

Demo

https://github.com/suleiman-dev/flashfeed-ai.git
You can run the app locally by cloning the repo, configuring environment variables, and running node index.js.
Here’s an example response from the /news endpoint:

[
  {
    "title": "The Russian Technocrat Who Helps Enable Putin and Manage the Ukraine War",
    "link": "https://www.nytimes.com/2025/08/10/world/europe/putin-russia-ukraine-war-sergei-kiriyenko.html",
    "pubDate": "Sun, 10 Aug 2025 09:23:00 +0000",
    "source": "NYTimes World",
    "ai_summary": "Sergei V. Kiriyenko has handled the political aspects of the war in Ukraine. ..."
  },
  ...
]

How I Used Redis 8
I used Redis 8 as a semantic caching layer for storing and quickly retrieving summarized news data. Each time the app fetches fresh news and generates AI summaries, it stores the combined result in Redis with an expiration time (TTL) of 1 hour. This reduces the need for repeated API calls to the Hugging Face service and accelerates response time for client requests.
Although Redis 8 supports advanced AI features like vector search, this project primarily leveraged Redis for fast caching of AI-generated content, demonstrating efficient integration of Redis with real-time AI APIs.
uploads.s3.amazonaws.com/uploads/articles/0bf3f40hyh1dhxdfuumv.PNG)

Habit Tracker

Suleiman Alhaji Mohammed — Sun, 19 Jan 2025 20:33:42 +0000

This is a submission for the GitHub Copilot Challenge : New Beginnings

Habit Tracker

Overview

The Habit Tracker is a web application that helps you track your habits and get AI-powered suggestions to stay on track. It allows you to add, delete, and monitor your habits, as well as view motivational quotes.

The Habit Tracker is a simple yet effective tool to help users build and maintain good habits. It provides a user-friendly interface to add, track, and delete habits, along with motivational quotes to keep users inspired.

Demo

https://suleiman743.github.io/habit-tracker/

Repo

GitHub Repository

Copilot Experience

Throughout the development process, I used GitHub Copilot to assist with writing HTML, CSS, and JavaScript. Copilot provided helpful suggestions for code snippets, animations, and overall structure, which significantly sped up the development process.

GitHub Models

I utilized GitHub Models for prototyping LLM capabilities in the app, particularly for generating habit suggestions and improving the user experience with AI-powered features.

Conclusion

Building the Habit Tracker was a rewarding experience. It not only helped me improve my coding skills but also demonstrated the potential of AI-powered tools like GitHub Copilot in streamlining the development process. This project has the potential to positively impact users by helping them build and maintain good habits.

License

This project is licensed under the MIT License.

Fun with Files File-Upload-to-IPFS

Suleiman Alhaji Mohammed — Sun, 13 Oct 2024 20:26:03 +0000

Overview

Fun with Files is a web application that allows users to upload files to the InterPlanetary File System (IPFS) using Pinata's API. This application provides a user-friendly interface with drag-and-drop functionality, real-time upload feedback, and displays the IPFS hash for easy access to uploaded files.

Technologies Used

Frontend: HTML, CSS, JavaScript
Backend: Node.js, Express
Database: N/A (IPFS for decentralized storage)
API: Pinata for IPFS integration

Installation

Clone the repository:

   git clone <repository-url>
   cd fun-with-files/backend

Install the necessary packages:

   npm install

Set up environment variables in a .env file:

   PINATA_API_KEY=<your_api_key>
   PINATA_SECRET_API_KEY=<your_secret_api_key>

Start the server:

   node app.js

Access the application source codes at https://github.com/SuleimanSoftDev/File-Upload-to-IPFS

Usage

Open the web application in your browser.
Use the drag-and-drop area or click to select files for upload.
Click the "Upload" button to initiate the upload.
View the IPFS link displayed after a successful upload.

File Upload Process

When a file is uploaded:

The file is sent to the backend server.
The server processes the file and uploads it to IPFS via the Pinata API.
The IPFS hash is returned and displayed on the frontend.

Accessibility Considerations

Keyboard Navigation: Users can navigate the application using the keyboard.
Color Contrast: Colors used meet WCAG guidelines for sufficient contrast.
Alt Text: All images will have descriptive alt attributes (if applicable).

Installation

Clone the repository:

   git clone <repository-url>
   cd fun-with-files/backend

Install the necessary packages:

   npm install

Set up environment variables in a .env file:

   PINATA_API_KEY=<your_api_key>
   PINATA_SECRET_API_KEY=<your_secret_api_key>

Start the server:

   node app.js

Access the application in your browser at http://localhost:5000/index.html.

Usage

Open the web application in your browser.
Use the drag-and-drop area or click to select files for upload.
Click the "Upload" button to initiate the upload.
View the IPFS link displayed after a successful upload.

File Upload Process

When a file is uploaded:

The file is sent to the backend server.
The server processes the file and uploads it to IPFS via the Pinata API.
The IPFS hash is returned and displayed on the frontend.

Accessibility Considerations

Keyboard Navigation: Users can navigate the application using the keyboard.
Color Contrast: Colors used meet WCAG guidelines for sufficient contrast.
Alt Text: All images will have descriptive alt attributes (if applicable).

Contributing

Contributions are welcome! Please feel free to submit a pull request or create an issue for any feature requests or bug reports.

License

This project is licensed under the MIT License.


## License
This project is licensed under the MIT License.

Alien Math Game

Suleiman Alhaji Mohammed — Sat, 21 Sep 2024 14:24:53 +0000

This is a submission for the Web Game Challenge, Build a Game: Alien Edition

The Alien Math Game is an educational HTML5 game designed to help players improve their math skills while having fun. Players solve math problems to destroy aliens that descend from the top of the screen. The game includes various features such as levels, timers, and a leaderboard (Performance).

Different types of math problems (addition, subtraction, multiplication, division)
Increasing difficulty as players progress
Time-based challenges with a countdown timer
Special rewards and power-ups
Leaderboard to track top scores

How to Play

Enter your name in the input box and click "Start Game".
Solve the math problems presented to you by entering the answer in the provided input box.
Destroy aliens by answering correctly before the timer runs out.
Keep an eye on your lives, score, and remaining aliens!
Try to complete all levels and achieve the highest score on the leaderboard!

https://binarybridge2024.github.io/Alien-Math-Blast/demo.html

License
This project is open-source and available under the MIT License
@Suleiman_Alhaji_Mohammed

3D Solar System Simulation

Suleiman Alhaji Mohammed — Thu, 12 Sep 2024 12:06:01 +0000

This is a submission for Frontend Challenge v24.09.04, Glam Up My Markup: Space

3D Solar System Simulation
The 3D Solar System Simulation is an interactive visualization that displays the planets of our solar system orbiting the sun in real-time. The planets' relative sizes and distances are modeled based on actual astronomical data, providing a realistic and engaging experience. This simulation was built using JavaScript and Three.js, a popular 3D graphics library, to create and render the planets in a web browser.

Demo
You can experience a live demo of the Solar System Simulation by visiting the following link:

https://github.com/BinaryBridge2024/solar-system-simulation/

User Management System

Suleiman Alhaji Mohammed — Mon, 02 Sep 2024 04:18:49 +0000

My Kit Overview

Is a User Management System built using Node.js, Express.js, and PostgreSQL. The system allows for basic CRUD (Create, Read, Update, Delete) operations on user data. It includes a RESTful API for backend operations and a simple frontend to interact with the API.

User Registration:
- Allows new users to register by providing a username, email, and password.
- Passwords are hashed before being stored in the database for security.
Retrieve Users:
- Fetch all users from the database or retrieve a single user by their unique ID.
Update User Information:
- Update the username, email, or password of an existing user.
Delete Users:
- Remove a user from the database based on their ID.
Error Handling:
- Enhanced error handling ensures that meaningful error messages are returned, aiding in debugging.

Technologies Used:

Backend:
- Node.js: Server-side runtime for handling requests.
- Express.js: Web framework for building the RESTful API.
- PostgreSQL: Database for storing user data.
- pg: Node.js library for interfacing with PostgreSQL.
- bcrypt: For hashing passwords before storing them in the database.
- CORS: Middleware to enable Cross-Origin Resource Sharing.

-Frontend:

Simple HTML and JavaScript to interact with the API endpoints for registration, updating, and deleting users.

Steps Involved:

Database Setup:
- A PostgreSQL database was configured with a users table containing fields for id, username, email, password, and created_at.
API Development:
- Routes were created for each CRUD operation (/api/register, /api/users, /api/users/:id, etc.).
- Controllers were implemented to handle the business logic for each operation.
- Middleware was used for handling errors and parsing JSON bodies.
Frontend Integration:
- A basic user interface was developed to allow for registration, viewing, updating, and deleting users.
- Fetch API was used to send HTTP requests to the backend.
Deployment:
- The project was uploaded to GitHub for version control and sharing.

The system can be used as a starter kit for building more complex user management applications or integrated into larger systems where user authentication and management are required. This project serves as a comprehensive example of building a full-stack web application, from backend API development to frontend interaction, using modern web technologies.

Project Link (https://github.com/BinaryBridge2024/My-Starter-Kit.git)

The Stack is very nice, Dev Community are good in providing educatable project for helping developers to get deep into their skills and I choose this stack to give my contributions to Developers to use my starter kit for developing their Apps. I learned how to work PostgreSQL database on Neon.

@suleiman_alhajimohammed_

Creating and Sending Transactions with Stellar’s JavaScript SDK

Suleiman Alhaji Mohammed — Sun, 18 Aug 2024 05:37:17 +0000

Let’s get into the tutorial on how to interact with the Stellar blockchain using its SDK. We’ll focus on creating and sending transactions with Steller's JavaScript SDK, which is useful for developers who want to integrate Stellar into their applications

Tutorial: Creating and Sending Transactions with Stellar’s JavaScript SDK

Prerequisites
Node.js: Ensure you have Node.js installed on your system. You can download it from nodejs.org.

Stellar SDK: We will use the Stellar SDK for JavaScript. You can install it using npm.

Basic JavaScript Knowledge: Understanding of JavaScript basics is helpful.

Stellar Account: You’ll need a Stellar account to interact with the Stellar network. You can create one using the Stellar Laboratory or other Stellar wallet providers.

Step 1: Setting Up Your Environment
First, create a new project directory and initialize it with npm:

mkdir stellar-tutorial cd stellar-tutorial npm init -y

Install the Stellar SDK:

npm install @stellar/sdk

Step 2: Writing the Code
Create a file named 'index.js' in your project directory and open it in your favorite code editor eg. Sublime Text, Visual Studio code and Bracket etc.
Add the following code to 'index.js':

`const StellarSdk = require('@stellar/sdk');
const fetch = require('node-fetch');
global.fetch = fetch;

// Configure network
const server = new StellarSdk.Server('https://horizon-testnet.stellar.org'); // Use testnet for development
const networkPassphrase = StellarSdk.Networks.TESTNET;

// Replace with your Stellar account details
const sourceSecretKey = 'YOUR_SOURCE_ACCOUNT_SECRET_KEY';
const destinationPublicKey = 'DESTINATION_ACCOUNT_PUBLIC_KEY';
const amount = '10'; // Amount to send in XLM

// Create a keypair from the source secret key
const sourceKeypair = StellarSdk.Keypair.fromSecret(sourceSecretKey);

// Create a transaction object
async function sendTransaction() {
try {
// Load source account
const account = await server.loadAccount(sourceKeypair.publicKey());

    // Create a payment operation
    const paymentOperation = StellarSdk.Operation.payment({
        destination: destinationPublicKey,
        asset: StellarSdk.Asset.native(),
        amount: amount
    });

    // Create a transaction
    const transaction = new StellarSdk.TransactionBuilder(account, {
        fee: StellarSdk.BASE_FEE,
        networkPassphrase: networkPassphrase
    })
    .addOperation(paymentOperation)
    .setTimeout(30)
    .build();

    // Sign the transaction
    transaction.sign(sourceKeypair);

    // Submit the transaction
    const response = await server.submitTransaction(transaction);
    console.log('Transaction successful:', response);
} catch (error) {
    console.error('Transaction failed:', error);
}

}

// Run the function
sendTransaction();`

Step 3: Understanding the Code

Network Configuration: We use the Stellar Testnet for development to avoid using real assets. For production, you’d use 'https://horizon.stellar.org' and 'StellarSdk.Networks.PUBLIC'.
Source and Destination Accounts: Replace 'YOUR_SOURCE_ACCOUNT_SECRET_KEY' with the secret key of the account sending the XLM, and 'DESTINATION_ACCOUNT_PUBLIC_KEY' with the public key of the recipient account.
Building the Transaction: We create a 'Payment' operation, build the transaction, sign it with the source account’s private key, and submit it to the network.
Error Handling: *The *'try...catch' block helps handle any errors that might occur during the transaction process.

Step 4: Running the Code
Run the script using Node.js:

node index.js

You should see a success message if everything goes smoothly. If there are issues, the error message will provide details on what went wrong.

Additional Tips
Stellar Laboratory: Use Stellar Laboratory for experimenting with transactions and key management.

Environment Variables: For security reasons, consider using environment variables to store sensitive information like secret keys.

Error Codes: Familiarize yourself with common Stellar error codes to troubleshoot issues effectively.