DEV Community: Tom Boyle

Machine Learning from Scratch: A Beginner-Friendly Open-Source Repo 🧠

Tom Boyle — Thu, 13 Mar 2025 05:39:01 +0000

Introduction

Machine Learning is everywhere—from recommendation systems to self-driving cars. But have you ever wondered how these algorithms actually work under the hood? Many tutorials focus on using high-level libraries like scikit-learn and TensorFlow, but understanding the fundamentals requires building ML models from scratch.

That's why I created ML-Algorithms—an open-source repository with clean Python implementations of essential ML algorithms. It’s designed to help beginners and professionals understand, modify, and experiment with machine learning techniques without black-box magic.

🌟 Why This Repo Stands Out

🔍 Clear, well-structured implementations for easy learning.
📝 Jupyter Notebooks for interactive exploration.
⚡ Minimal dependencies—just Python & NumPy.
🎯 Beginner-friendly yet deep enough for pros.

💬 Join the conversation: Share your thoughts, ask questions, and contribute ideas in the GitHub Discussions.

🔎 What’s Inside?

The repository includes well-documented Python implementations of:

✅ Supervised Learning (Linear Regression, Decision Trees)

✅ Unsupervised Learning (K-Means Clustering, PCA)

✅ Reinforcement Learning (Q-Learning, Deep Q-Network)

✅ Deep Learning (Neural Networks, CNNs)

Each algorithm comes with:

Simple Python implementations (no unnecessary dependencies).
Clear explanations with comments.
Jupyter Notebooks to visualize results.

⚙️ How It Works (Example: Decision Trees 🌳)

Let's break down a simple Decision Tree implementation from the repo.

class DecisionTree:
    def __init__(self, max_depth=None):
        self.max_depth = max_depth

    def fit(self, X, y):
        self.tree = self._grow_tree(X, y)

    def _grow_tree(self, X, y, depth=0):
        if depth == self.max_depth or len(set(y)) == 1:
            return np.argmax(np.bincount(y))

        feature, threshold = self._best_split(X, y)
        left_idx, right_idx = X[:, feature] <= threshold, X[:, feature] > threshold
        return (feature, threshold, 
                self._grow_tree(X[left_idx], y[left_idx], depth + 1),
                self._grow_tree(X[right_idx], y[right_idx], depth + 1))

🔹 What’s happening here?

The _grow_tree method recursively splits the dataset based on the best feature.
Once it reaches the max depth, it assigns the most common class.
Simple, effective, and easy to modify!

📸 Want to see it in action? Here’s an example output visualization:

💻 Try It Yourself (Google Colab 🚀)

Want to run the code without setting up anything? Click below to open the repo in Google Colab:

📣 Boosting Open-Source Visibility – Join the Movement!

🚀 If you find this project valuable, here’s how you can help it grow:

✅ Star the repo on GitHub ⭐

✅ Share the repo on X (Twitter), LinkedIn, or Dev.to

✅ Contribute by adding new algorithms or improvements 🛠️

🌍 Join the discussion & connect with ML enthusiasts!

💬 GitHub Discussions – Ask questions, suggest features, and share insights!

🔗 Follow Me for More ML & AI Content

📢 I share AI research, coding projects, and ML insights on my socials:

📌 X (Twitter): @tomlikestocode

🌍 Personal Website: tomboyle.io

🔗 Let’s connect and build amazing AI projects together!

What’s an ML algorithm you’ve struggled with before? Let me know in the comments! 🚀

Leveraging AI for Personalized User Experiences: A Practical Guide

Tom Boyle — Sat, 04 Jan 2025 10:32:06 +0000

Welcome to 2025, where personalized user experiences (UX) are no longer optional but essential. Thanks to advancements in AI, businesses and developers are now crafting hyper-personalized digital interactions that delight users and keep them coming back for more. Whether you're in e-commerce, healthcare, or any digital-first industry, this guide will show you how to leverage AI to create tailored, impactful experiences.

Why Personalization Matters in 2025

1. User Expectations Are Skyrocketing

Modern users demand more than generic interactions. They crave experiences that feel tailor-made. AI makes it possible to anticipate their needs and provide solutions before they even ask.

2. Standing Out in a Crowded Market

With businesses vying for attention, personalization is your secret weapon to outshine competitors. It boosts satisfaction, drives loyalty, and skyrockets conversions.

3. Data-Driven Insights for the Win

AI turns mountains of data into actionable insights, uncovering what your users truly want and helping you deliver exactly that.

Key AI Trends in Personalized UX for 2025

1. Context-Aware Personalization

AI now leverages real-time data such as location, time of day, and even device usage to create hyper-relevant experiences.

Example: Fitness apps offering workout suggestions based on local weather and your fitness tracker data.

2. Generative AI in UX Design

Tools like ChatGPT and generative models are reshaping how we design dynamic interfaces and content.

Example: Personalized emails or landing pages dynamically created for each user.

3. Predictive Behavior Models

AI anticipates user actions with stunning accuracy, letting you personalize proactively.

Example: Shopping platforms offering discounts on items users are likely to buy.

4. Emotion Recognition

AI can now analyze user emotions through text, voice, and even facial expressions, enhancing personalization.

Example: Chatbots adapting their tone to match a frustrated or happy customer.

5. Multi-Modal Personalization

By combining inputs like text, images, and voice, AI is creating inclusive, intuitive experiences.

Example: Smart assistants suggesting recipes based on your spoken dietary preferences and pantry inventory.

How to Implement Personalized Experiences Using AI

1. Know Your Users Inside Out

Data is king—but collecting it responsibly is crucial. Focus on user preferences, behaviors, and demographics, while staying compliant with privacy regulations.

2. Pick the Right Tools

Here are some tools to kickstart your AI personalization:

Hugging Face for natural language processing (NLP).
TensorFlow for building machine learning models.
AWS Personalize for plug-and-play personalization.

3. Start Small, Think Big

Begin with simple features like product recommendations. Iterate and expand as you learn more about your users.

4. Leverage Real-Time Data

Use AI to adapt experiences on the fly based on real-time inputs.

Example: Music apps curating playlists based on your current mood, detected via wearable devices.

5. Test, Optimize, Repeat

A/B testing is your best friend. Use it to refine features and optimize algorithms.

Case Study: Personalized Webpage Agents in 2025

Imagine landing pages that adapt uniquely to each visitor—that’s the power of personalized webpage agents. Here’s how they work:

How It Works:

An AI agent gathers user data from public interactions.
It compiles a fact sheet with key insights about user preferences.
A dynamic landing page is generated in real-time, optimized for engagement and conversions.

Tools to Build Your Own:

OpenAI API for dynamic content generation.
Figma for rapid UI/UX design.
Next.js and Tailwind CSS for responsive web development.

The Future of AI-Driven Personalization

As we move further into 2025 and beyond, here’s what’s on the horizon:

1. AI-Driven Creativity

Generative AI will autonomously craft entire user journeys.

2. Seamless Ecosystems

Imagine personalization that follows you across devices and platforms, creating a unified experience.

3. Ethical Personalization

Balancing personalization with privacy through federated learning and edge AI will be critical.

Conclusion

The days of one-size-fits-all digital experiences are gone. AI-driven personalization is not just the future—it’s the now. By embracing these trends and tools, you can create impactful, user-centric designs that engage, delight, and retain your audience. The time to innovate is today—let’s shape the future together!

Building Blazing Fast Websites with Next.js and Static Site Generation (SSG)

Tom Boyle — Thu, 10 Oct 2024 19:08:23 +0000

In today’s fast-paced world, users expect websites to load quickly and perform seamlessly. One of the best ways to ensure this performance is by building static websites. But manually creating static files and managing them can become cumbersome as your site grows. This is where Next.js comes in, offering powerful tools like Static Site Generation (SSG) to automate the process and optimize performance without sacrificing flexibility.

In this article, I’ll guide you through how to build blazing fast websites using Next.js and its SSG capabilities. We’ll cover the basics of SSG, how it works, and how to implement it, along with some advanced tips to further enhance your site’s performance.

What is Static Site Generation (SSG)?

Static Site Generation (SSG) is a method of pre-rendering HTML pages at build time, meaning the pages are generated before a user makes a request. Once generated, the static HTML files can be served instantly, leading to faster load times compared to Server-Side Rendering (SSR), which generates pages on the fly.

With SSG, the pages remain static unless they’re re-built, which makes it ideal for pages that don’t need to change often (e.g., blogs, documentation, landing pages). This approach enhances performance because static files are quicker to serve and can be cached efficiently by CDNs (Content Delivery Networks).

Key Benefits of Using SSG in Next.js:

Performance Boost: Since pages are pre-rendered at build time, they can be served almost instantly, reducing time-to-first-byte (TTFB) and overall load time.
SEO-friendly: Pre-rendered HTML is fully optimized for search engine crawlers, helping you improve your SEO rankings.
Scalability: Static files can be deployed to CDNs, allowing your website to handle large traffic volumes with ease.
Security: With no direct interaction with a server for every request, SSG reduces the risk of security vulnerabilities like server-side attacks.

Now that you understand why SSG is beneficial, let’s dive into how to implement it in a Next.js project.

Setting Up Your Next.js Project

If you don’t have a Next.js project yet, start by creating one:

npx create-next-app my-static-site
cd my-static-site
npm run dev

This will create a basic Next.js project. You can access the development server at http://localhost:3000.

Enabling Static Site Generation in Next.js

To generate static pages in Next.js, you need to use the getStaticProps function. This function is called at build time, and it allows you to fetch data, which is then passed to your page as props.

Here’s a basic example of how to create a static blog page:

// pages/blog/[slug].js

export async function getStaticProps({ params }) {
  const blogPost = await fetch(`https://api.example.com/blog/${params.slug}`);
  const postData = await blogPost.json();

  return {
    props: {
      postData,
    },
  };
}

export async function getStaticPaths() {
  const posts = await fetch('https://api.example.com/blog');
  const postsData = await posts.json();

  const paths = postsData.map((post) => ({
    params: { slug: post.slug },
  }));

  return {
    paths,
    fallback: false,
  };
}

const BlogPost = ({ postData }) => {
  return (
    <article>
      <h1>{postData.title}</h1>
      <p>{postData.content}</p>
    </article>
  );
};

export default BlogPost;

Breakdown:

getStaticProps: This function fetches data at build time and passes it to the component as props.
getStaticPaths: This function generates all the possible paths for the dynamic routes (in this case, blog slugs). It ensures that all these pages are statically generated when you build the site.
fallback: false: This ensures that any route not returned by getStaticPaths will show a 404 page.

When you run npm run build, Next.js will generate static HTML files for each blog post, which will be served instantly to users.

Optimize Your SSG Setup

To ensure your site is as fast as possible, follow these additional tips:

1. Use Incremental Static Regeneration (ISR)

With Next.js, you’re not limited to completely static pages. If you want to periodically update static pages without rebuilding the entire site, you can use Incremental Static Regeneration (ISR).

ISR allows you to update static pages at runtime, regenerating them in the background based on a specified interval.

Here’s how to use ISR:

export async function getStaticProps() {
  const postData = await fetch('https://api.example.com/blog');

  return {
    props: {
      postData,
    },
    revalidate: 60, // Re-generate the page every 60 seconds
  };
}

The revalidate key allows you to define how often the page should be updated in seconds. For example, setting it to 60 means the page will regenerate every 60 seconds if a user requests it.

2. Image Optimization

Next.js provides built-in image optimization, which ensures that images are loaded in the most efficient format and size for the user’s device.

Use the next/image component to add responsive images to your static pages:

import Image from 'next/image';

const BlogPost = ({ postData }) => {
  return (
    <article>
      <h1>{postData.title}</h1>
      <Image
        src={postData.imageUrl}
        alt={postData.title}
        width={800}
        height={600}
      />
      <p>{postData.content}</p>
    </article>
  );
};

Next.js will automatically handle lazy loading, responsive resizing, and format selection for your images, making sure they load quickly and look sharp.

3. Cache Control with CDN

One of the main benefits of static files is that they can be easily cached by a Content Delivery Network (CDN). When you deploy your static Next.js site to platforms like Vercel or Netlify, these platforms automatically handle CDN caching for you, reducing the time it takes to load your pages for users all around the world.

However, if you’re deploying on your own infrastructure, make sure you have proper caching headers set for your static assets.

4. Prefetching Links for Faster Navigation

Next.js automatically prefetches links that are in the viewport, which makes client-side navigation faster. However, you can manually prefetch links if needed:

import Link from 'next/link';

const Blog = ({ posts }) => {
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>
          <Link href={`/blog/${post.slug}`} prefetch={false}>
            {post.title}
          </Link>
        </li>
      ))}
    </ul>
  );
};

This small optimization improves user experience, especially for pages that may have dynamic content.

Conclusion

With Static Site Generation (SSG) in Next.js, you can create lightning-fast websites that provide a smooth user experience and are optimized for performance out of the box. By combining SSG with Incremental Static Regeneration (ISR), Image Optimization, and CDN caching, you can push your site’s performance to the next level.

If you haven’t already, give SSG a try in your next project. You’ll see how easy it is to implement, and your users will thank you for the fast load times!

For more insights and tips, make sure to follow me on X, where I regularly share coding advice and updates on my projects.

Additional Resources:
Next.js Official Documentation
SSG, SSR & ISR in by Dave Gray

Feel free to drop your questions or comments below—I'm always happy to help others become better at coding with Next.js!

Optimizing API Calls in Backend Integration: A Developer's Guide

Tom Boyle — Wed, 18 Sep 2024 09:01:15 +0000

When building modern applications, efficient backend integration is crucial. At the heart of this process are API calls, which facilitate communication between services, databases, and third-party platforms. However, poorly optimized API calls can lead to performance bottlenecks, increased latency, and higher server costs. In this article, I’ll cover essential strategies to optimize API calls for your backend, ensuring both performance and scalability.

Batch Requests Instead of Single Calls

In scenarios where you need to retrieve or send multiple pieces of data, it’s more efficient to batch requests together. Instead of sending multiple API requests one after another, you can group them into a single call. This reduces overhead and the number of round trips between the client and server.

Example:

Let’s say you’re fetching user data and order information. Instead of making two API requests like this:

// Fetch user data
axios.get('/api/user/123')

// Fetch order information
axios.get('/api/user/123/orders')

You can create an endpoint that returns both pieces of data in a single request:

axios.get('/api/user/123/with-orders')

By doing this, you minimize the number of HTTP connections and overall processing time, significantly boosting performance.

Cache Frequently Used Data

Caching is a powerful technique for reducing redundant API calls. If certain data doesn’t change frequently (like user settings or product information), storing the results in a cache can help avoid unnecessary requests to the server.

Common Caching Methods:
In-Memory Cache (e.g., Redis, Memcached): Great for fast, frequently accessed data.
HTTP Cache Headers: Utilize cache headers like ETag or Cache-Control to reduce redundant calls from the client.
Application-level Caching: Store data locally in your app’s memory for temporary reuse.
Example:

// Check if data exists in cache
let userData = cache.get('user_123');
if (!userData) {
  userData = await axios.get('/api/user/123');
  cache.set('user_123', userData);  // Cache the data for future use
}

This way, you only make the API call if the data isn't already available in your cache.

Limit Payload Size

When dealing with large datasets, fetching too much information can slow down API performance and increase latency. Always aim to limit the amount of data returned by an API call using techniques like pagination, filtering, and selective field retrieval.

Example:

If you’re only interested in the name and email fields of a user, avoid fetching the entire user object:

// Inefficient API call returning the whole user object
axios.get('/api/user/123')

// Optimized API call returning only selected fields
axios.get('/api/user/123?fields=name,email')

Similarly, for large datasets, implement pagination to break down the data into manageable chunks.

// API call with pagination
axios.get('/api/orders?page=1&limit=50')

Asynchronous Processing and Parallel Requests

If your backend needs to make multiple API calls to complete a task, performing them asynchronously can save significant time. Instead of executing one API call and waiting for its response before making the next, fire off multiple API calls in parallel and handle them concurrently.

Example:

// Parallel API calls
const [userResponse, ordersResponse] = await Promise.all([
  axios.get('/api/user/123'),
  axios.get('/api/user/123/orders')
]);

By leveraging Promise.all, the two API calls are executed simultaneously, reducing total execution time.

Optimize API Request Frequency

It's important to ensure that your API calls are made only when necessary. Implement mechanisms like polling, webhooks, or server-sent events (SSE) to avoid frequent or unnecessary requests.

Polling is useful for checking for new data periodically, but if overused, it can lead to inefficient usage of resources. Be sure to increase the interval between requests when possible.
Webhooks provide a more efficient solution by having the server notify the client of events rather than having the client repeatedly request information.
SSE and WebSockets can be used for real-time data updates without repeatedly querying the API. #### Example: ###### Polling vs. Webhooks Polling:

// Polling every 5 seconds (not ideal for high-frequency updates)
setInterval(() => {
  axios.get('/api/notifications');
}, 5000);

Webhook:

// Use a webhook to receive notifications in real time

By switching to a webhook or SSE, you reduce unnecessary API calls and handle updates more efficiently.

Rate Limiting and Throttling

When making frequent API calls, especially to third-party services, always respect rate limits and use throttling to control the frequency of requests. Exceeding these limits can lead to errors, downtime, or even blacklisting by service providers.

Example:

To avoid hitting API rate limits, implement a rate limiter that queues or pauses requests when necessary:

const axiosRateLimit = require('axios-rate-limit');

// Create a rate-limited axios instance
const http = axiosRateLimit(axios.create(), { maxRPS: 5 });

// Will make at most 5 requests per second
http.get('/api/some-endpoint');

This ensures you don’t overwhelm the API server with too many requests at once.

Use Gzip Compression

If you’re sending or receiving large amounts of data over API requests, enable gzip compression to reduce payload size. Most modern APIs support this feature, and it can greatly improve performance, especially for APIs that handle large text-based data like JSON.

Example:

Enable gzip compression on your server by including this header in your request:

axios.get('/api/data', {
  headers: {
    'Accept-Encoding': 'gzip'
  }
});

On the server side, configure the API to compress responses.

Conclusion

Optimizing API calls in backend integration is essential for building scalable, fast, and cost-efficient applications. Whether you're batching requests, caching data, or implementing asynchronous operations, each step towards optimization will improve the overall performance of your system. By following these strategies, you can ensure smooth communication between your services while minimizing latency and resource usage.

Thanks for reading! If you enjoyed this post and want to dive deeper into backend development, API optimizations, and more, feel free to follow me on X. I regularly share tips, tutorials, and insights on web development and software engineering. Let’s continue the conversation and learn together!

Creating a twitter bot to automatically post Bitcoin and Ethereum prices.

Tom Boyle — Sat, 19 Nov 2022 04:51:31 +0000

I am currently working on a crypto-themed website and was looking to market the website on twitter. A lot of guides just tell you that you need to be active on the platform however I don’t want to be sitting liking tweets and commenting all day. I decided there had to be a way to automate this and reminded me of a first-year project I completed university where we used the Twitter API to post tweets on our behalf.

The goal of this project is to automatically tweet price signals combining the knowledge gained from my Twitter API project and the CoinGecko API. Firstly, there are a couple requirements for this project:

· Python (latest version). Python is a computer programming language often used to build websites and software, automate tasks, and conduct data analysis. Python is a general-purpose language, meaning it can be used to create a variety of different programs and isn’t specialized for any specific problems.

· Tweepy. An easy-to-use Python library for accessing the Twitter API.

· Twitter account. Twitter is a microblogging and social networking service.

· Twitter developer account. This account allows you to use the Twitter API to analyze, learn from, and interact with Tweets, Direct Messages, and users.

Once you have set up each of the above requirements you will be ready to commence the project. Please see the source code below:

import tweepy
import requests
import json
import time

API_KEY = ""
SECRET_KEY = ""
ACCESS_TOKEN = ""
ACCESS_TOKEN_SECRET = ""

auth_handler = tweepy.OAuthHandler(consumer_key=API_KEY, consumer_secret=SECRET_KEY)
auth_handler.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)

api = tweepy.API(auth_handler, wait_on_rate_limit=True)

print('logged in')

while True:
    bitcoinprice = requests.get('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd')
    price = bitcoinprice.json()
    btcusd = price['bitcoin']['usd']
    print(btcusd)

    message = "$BTC currently trading at: $" + str(btcusd) + " USD. #BTC"
    api.update_status(message)

    print('Tweet posted.')

    ethereumprice = requests.get('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd')
    price = ethereumprice.json()
    ethusd = price['ethereum']['usd']
    print(ethusd)

    message = "$ETH currently trading at: $" + str(ethusd) + " USD. #ETH"
    api.update_status(message)

    print('Tweet posted.')

    time.sleep(6000)

Feel free to follow me on github or twitter.