MoreRSS

site iconThe Practical DeveloperModify

A constructive and inclusive social network for software developers.
Please copy the RSS to your reader, or quickly subscribe to:

Inoreader Feedly Follow Feedbin Local Reader

Rss preview of Blog of The Practical Developer

MediaTek Dimensity 9500s and Dimensity 8500 Debut for Android's 'Flagship Killer' Phones

2026-01-31 08:00:05

MediaTek Dimensity 9500s and Dimensity 8500 Debut for Android's 'Flagship Killer' Phones

Table of Contents

  1. Introduction to MediaTek Dimensity 9500s and Dimensity 8500
  2. Specifications and Features
  3. Performance and Efficiency
  4. Comparison with Other Processors
  5. Reading Recommendations

Introduction to MediaTek Dimensity 9500s and Dimensity 8500

MediaTek, one of the major players in the smartphone processor industry, has recently launched two highly anticipated new processors, the Dimensity 9500s and Dimensity 8500. These processors are designed to meet the needs of high-end Android smartphones, often referred to as "flagship killers" because they offer high performance at a more affordable price compared to pure flagship devices.

Specifications and Features

The Dimensity 9500s and Dimensity 8500 come with several impressive features and specifications. The Dimensity 9500s is built with a 4nm manufacturing process and features a powerful CPU architecture, including Arm Cortex-A78 and Cortex-A55 cores for balanced performance between power and efficiency. Meanwhile, the Dimensity 8500 also uses a 4nm manufacturing process and has a similar CPU configuration, with adjustments to optimize performance and power consumption.

Both processors are also equipped with enhanced graphics capabilities, making them ideal for gaming and applications that require high graphics rendering. In addition, they support features such as 5G, Wi-Fi 6E, and Bluetooth 5.3, ensuring fast and stable connections.

Performance and Efficiency

In terms of performance, both the Dimensity 9500s and Dimensity 8500 promise significant improvements compared to their predecessors. They offer faster CPU performance and improved power efficiency, which means users can enjoy a more responsive smartphone experience and longer battery life.

Also Read: Android 16 QPR3 Introduces 'Screen Automation' Feature on Pixel 10 for Computer Use

Comparison with Other Processors

Compared to other processors in their class, the Dimensity 9500s and Dimensity 8500 offer a unique combination of high performance, power efficiency, and advanced features. They are ready to compete with flagship processors from other vendors, while offering a more competitive price, making them very attractive to those looking for a true "flagship killer".

Reading Recommendations

FAQ
Q: What makes the Dimensity 9500s and Dimensity 8500 special?
A: Both offer high performance, good power efficiency, and advanced features like 5G and Wi-Fi 6E, making them ideal for high-end Android smartphones at an affordable price.

Q: When will the Dimensity 9500s and Dimensity 8500 be available in the market?
A: Specific market availability information has not been announced, but it is expected to be available in the coming months.

Q: Do the Dimensity 9500s and Dimensity 8500 support 5G technology?
A: Yes, both support 5G technology, allowing users to enjoy very fast internet connections.

VoxTube – Convert YouTube videos to audio with local TTS

2026-01-31 07:37:08

I built a tool to convert YouTube videos into podcasts

Body

Problem: I kept queuing YouTube tutorials and talks but never watching them. Video demands attention in a way that audio doesn't.

Solution: VoxTube extracts transcripts from YouTube videos and converts them to audio using high-quality TTS.

Now I "watch" YouTube during my commute, while cooking, and during workouts.

Technical details:

  • Built with Bun + Hono (~300 lines)
  • Uses Kokoro TTS (runs locally via Docker)
  • Caches generated audio
  • No cloud dependencies

What I learned:

  • Bun's file APIs are really nice for streaming audio
  • Modern TTS (Kokoro) sounds surprisingly natural
  • Most YouTube videos have transcripts available

Stats:

  • 2 weeks to MVP
  • ~300 lines of code
  • 0 monthly costs (runs locally)

GitHub: https://github.com/shawn-dsz/voxtube

Happy to answer questions about the build!

Running the Copilot CLI in a WebGL-powered retro CRT terminal implemented by the Copilot CLI 🤯

2026-01-31 07:33:50

This is a submission for the GitHub Copilot CLI Challenge

What I Built

A port of Swordfish90/cool-retro-term (Qt and OpenGL) to WebGL, React, and Electron, and use to make my website look like a cool retro monochrome CRT monitor with an OS from 1977.

Demo

https://remojansen.github.io/

Please note: The site is meant to be used with a keyboard (no mouse or touch controls).

My Experience with GitHub Copilot CLI

I first had the idea of building a website that looks like an old-style monochrome CRT monitor when I discovered Swordfish90/cool-retro-term. I loved it, but the problem is that cool-retro-term is a native application that uses Qt & OpenGL. I wondered if it would be possible to port the code to WebGL, but because I have no experience with Qt or OpenGL, answering this question would have taken me many hours.

In the past, I wouldn't have pursued this project because I didn't have much time outside of work, but now, thanks to GitHub Copilot and its CLI, I was able to get a good understanding of how cool-retro-term works and put together a migration plan in minutes.

Then, over a couple of evenings, I started to migrate the OpenGL shaders to WebGL one at a time, and soon I had a working port 🎉

https://remojansen.github.io/

The original project (cool-retro-term) implemented an OpenGL frontend for an OS terminal. My website runs in a browser, so I had to implement a basic terminal emulator, and Copilot was able to do so without any problems.

Because the rendering was decoupled from the terminal, I thought others could be interested in this as a library, so I released it as cool-retro-term-webgl, and I also thought that the most likely next usage would be an Electron-based version of cool-retro-term so I also added that to cool-retro-term-webgl.

Now I can run the Copilot CLI in a WebGL-powered retro CRT terminal implemented by the Copilot CLI 🤯

GitHub Copilot CLI in cool-retro-term-electron

I was very happy with everything that I was able to accomplish in just a couple of days, and quite impressed by the power of the GitHub Copilot Agents together with Claude Opus 4.5. It was then that the fan really started. I started to add all sorts of cool and fun "programs" to my terminal emulator, and honestly, I have not had so much fun coding in a very long time.

Games in https://remojansen.github.io

There are a couple of fun easter eggs and nerdy references. I hope you enjoy them (maybe you can "hack" my cluster 😉).

Solved: How to force alt images tag with product title

2026-01-31 07:12:20

🚀 Executive Summary

TL;DR: E-commerce themes often overlook populating image alt tags with product titles, leading to significant SEO and accessibility issues. This guide offers three solutions: a quick client-side JavaScript patch, a permanent server-side template edit, and a high-risk direct database update for existing images.

🎯 Key Takeaways

  • Missing alt tags are typically a theme template oversight, not a core platform bug, residing in the presentation layer’s HTML output.
  • A client-side JavaScript (jQuery) solution can quickly inject product titles into empty alt tags, acting as a temporary band-aid for immediate SEO audit fixes.
  • The permanent and most reliable fix involves modifying server-side theme template files (e.g., product-image.php in WooCommerce) within a child theme to dynamically fetch and insert the product title into the alt attribute.
  • For bulk updates of existing images lacking alt text, a direct SQL database query can be used, but it carries a very high risk and necessitates a full database backup.
  • Browser developer tools are crucial for identifying correct CSS classes, which serve as clues to locate the relevant theme template files for server-side modifications.

Tired of SEO audits flagging missing alt text on product images? Learn three practical methods—from a quick client-side patch to a permanent server-side fix—to automatically populate image alt tags with your product titles.

So, Your “SEO-Friendly” Theme Forgot About Alt Tags. Now What?

I remember it like it was yesterday. We’d just pushed a beautiful new theme to our main e-commerce cluster, ecom-web-prod-01 through 04. Everyone was thrilled. Two days later, a high-priority ticket lands in my queue: “URGENT: SEO Score Dropped 30 Points.” Our Head of Marketing was in a panic. Turns out, the fancy new theme’s gallery didn’t pull the product title for the image alt tags. We had thousands of products, and every single image was now an accessibility and SEO black hole. Fun times.

This situation is incredibly common. You get a theme or a plugin, it promises the world, but it misses one tiny, critical detail. And when you’re dealing with accessibility and search engine rankings, the alt tag is anything but tiny. So, let’s walk through how we fix this, from the quick-and-dirty to the permanent solution.

First, Why Does This Even Happen?

It’s almost never a core platform bug (whether you’re on Magento, Shopify, or WooCommerce). The problem almost always lives in the theme’s template files. These are the files that control the HTML output. A developer, rushing to meet a deadline, simply forgot to add the code that fetches the product’s name and inserts it into the alt attribute of the ![]() tag.

The image tag in the template probably looks like this:

<img src="path/to/your/image.jpg" alt="">

When what we really need is something that dynamically inserts the title, like this (using PHP as an example):

<img src="path/to/your/image.jpg" alt="<?php echo $product->getName(); ?>">

Understanding this is key. We’re not fixing a deep system flaw; we’re correcting an oversight in the presentation layer. Now, let’s look at our options.

Solution 1: The Quick Fix (Client-Side JavaScript)

This is my “I need to get this fixed in the next 15 minutes before the next status meeting” solution. It uses JavaScript (specifically jQuery, which is common in e-commerce platforms) to find the product title on the page and inject it into any empty alt tags within the product’s container.

The How-To:

You can add this script to your theme’s footer or via a tag manager. It waits for the document to be ready, finds the main product title, and then applies that text to the primary product image’s alt tag.

<script>
jQuery(document).ready(function($) {
    // Find the main product title on the page. You may need to adjust this selector.
    var productTitle = $('h1.product_title').text().trim();

    // Check if a title was actually found
    if (productTitle) {
        // Find the main product image and set its alt tag if it's empty.
        // Again, this selector for the image might need adjustment for your theme.
        var productImage = $('.woocommerce-product-gallery__image img');

        if (productImage.length > 0 && !productImage.attr('alt')) {
            productImage.attr('alt', productTitle);
        }
    }
});
</script>

Warning: This is a band-aid. It fixes the problem for users and web crawlers that execute JavaScript, but it doesn’t fix the root cause. The alt tag is still empty in the initial HTML source. It’s a hack, but a very effective one in a pinch.

Solution 2: The Permanent Fix (Server-Side Template Edit)

This is the right way to do it. We’re going into the theme files and fixing the code at the source. This ensures the correct HTML is served from the server every single time. No waiting for JavaScript, no flicker, no hacks.

The How-To:

You’ll need to SSH into your server or use an FTP client. The hardest part is finding the right file. In a WooCommerce world, you’re often looking for files within your theme folder like your-theme/woocommerce/single-product/product-image.php.

  1. Create a child theme. Never edit your parent theme files directly, or your changes will be overwritten during the next update.
  2. Locate the template file responsible for displaying the product image.
  3. Find the <img> tag.
  4. Modify the alt attribute to pull the product title dynamically.

You’ll change code that looks like this:

// Example of 'before' code
$html = '<div class="woocommerce-product-gallery__image"><a href="' . esc_url( $full_size_image[0] ) . '">';
$html .= wp_get_attachment_image( $post_thumbnail_id, 'woocommerce_single', false, array(
    'title' => $props['title'],
    'alt'   => '' // The culprit is often an empty or missing alt key
) );
$html .= '</a></div>';

To something like this, ensuring the product title is passed as the alt text:

// Example of 'after' code
global $product;
$product_title = $product->get_name();

$html = '<div class="woocommerce-product-gallery__image"><a href="' . esc_url( $full_size_image[0] ) . '">';
$html .= wp_get_attachment_image( $post_thumbnail_id, 'woocommerce_single', false, array(
    'title' => $product_title,
    'alt'   => $product_title // The fix!
) );
$html .= '</a></div>';

Pro Tip: Use your browser’s developer tools to inspect the HTML around the image. The CSS classes (like woocommerce-product-gallery\_\_image) are huge clues that will help you grep for the right file on your server.

Solution 3: The ‘Nuclear’ Option (Direct Database Update)

Sometimes, the problem isn’t just in the theme. You might have thousands of images already in your media library with no alt text. The template fix only applies to newly rendered product pages. For everything else (like images embedded in blog posts), you might need to go straight to the source: the database.

This is dangerous. Back up your database first. Seriously. Do it now. Test this on a staging server like staging-db-01 before even thinking about production.

The How-To:

This SQL query (for WordPress/WooCommerce) finds all image attachments that are assigned to a product (a post of type ‘product’) and updates their \_wp\_attachment\_image\_alt metadata field with the product’s title if the alt text is currently empty.

UPDATE wp_postmeta AS pm
JOIN wp_posts AS p_attachment ON pm.post_id = p_attachment.ID
JOIN wp_posts AS p_product ON p_attachment.post_parent = p_product.ID
SET pm.meta_value = p_product.post_title
WHERE pm.meta_key = '_wp_attachment_image_alt'
  AND (pm.meta_value IS NULL OR pm.meta_value = '')
  AND p_attachment.post_type = 'attachment'
  AND p_product.post_type = 'product';

This is a powerful, one-time-run query that can fix years of neglect in seconds. But with great power comes great responsibility. One wrong JOIN or WHERE clause and you could be restoring from that backup you (hopefully) made.

Choosing Your Weapon

Deciding which path to take depends on your situation. Here’s how I break it down for my team:

Method Speed Reliability Risk
1. JavaScript Fix Very Fast (Minutes) Medium (Client-side) Low
2. Template Fix Medium (1-2 Hours) High (Server-side) Medium
3. Database Update Fast (Minutes) High (Permanent Data) Very High

In the end, we went with Solution 2 for that frantic marketing ticket. It was the only way to truly fix the problem for good. But you can bet I considered throwing that JavaScript snippet in there just to stop the alerts while I dug through the theme’s spaghetti code. Sometimes, you need the band-aid before you can perform the surgery.

Darian Vance

👉 Read the original article on TechResolve.blog

Support my work

If this article helped you, you can buy me a coffee:

👉 https://buymeacoffee.com/darianvance

Solved: Spending €1.1M/month on Google Ads… and support can’t resolve even basic issues

2026-01-31 07:10:18

🚀 Executive Summary

TL;DR: High-spending cloud customers frequently encounter inadequate support from providers like Google, leading to significant outages and financial losses. The core solution involves architecting systems for resilience through automated multi-region/multi-cloud failover, proactive engagement with Technical Account Managers, and robust observability to minimize dependency on provider support.

🎯 Key Takeaways

  • Implement a “No Single Point of Support” architecture using automated multi-region or multi-cloud failover with a global load balancer independent of any single provider (e.g., Cloudflare, Akamai).
  • Proactively engage your Technical Account Manager (TAM) for strategic architectural reviews and to leverage their internal network and social capital, rather than using them solely for reactive escalations.
  • Invest heavily in your observability stack (Prometheus, Grafana, OpenTelemetry) to generate undeniable data that precisely identifies provider-side issues, forcing direct escalation past Tier 1 support.

Spending €1.1M/month on Google Ads… and support can’t resolve even basic issues

When you’re a massive cloud spender but can’t get competent support for basic issues, it’s a systemic failure, not a personal one. The key isn’t to yell louder at support; it’s to architect your systems for resilience against the provider’s own bureaucracy.

I Felt That Reddit Post In My Bones

It was 3 AM. The on-call phone blared to life, and I rolled out of bed to see our primary Postgres cluster, pg-prod-us-east-1-a, in a connection-storm panic. We were a top-tier customer, spending six figures a month with our cloud provider, and our “Premium Enterprise Support” contract was supposed to be our silver bullet. An hour into the P1 outage, all we had was a ticket number and a junior agent on the other end of the line asking if we’d tried restarting the instance. We were burning thousands of dollars a minute, and our lifeline was a human-shaped knowledge base article. So when I saw that Reddit thread about a company spending over a million a month and getting the same runaround, I didn’t just sympathize. I had flashbacks.

That feeling of total helplessness, where your entire business is at the mercy of a support queue you have no control over, is something no engineer should have to experience. But we all do.

The truth is, your million-dollar bill doesn’t buy you a magic wand. It just gets you a slightly better seat in the same broken theater. Let’s talk about why this happens and how we, as engineers, can build systems that make their support queue irrelevant.

Why Your Spend is Just a Number on Their Spreadsheet

It’s simple, brutal math. To a cloud giant like Google, AWS, or Azure, even €1.1M a month is a rounding error. Their support model is built for mass-scale ticket deflection, not nuanced problem-solving. It’s a funnel designed to keep their expensive, high-level engineers away from the noise.

  • Tier 1 Triage: The first person you talk to is following a script. Their job is to link you to a doc and close the ticket.
  • The “Prove It’s Us” Game: The default assumption is that the problem is your code, your configuration, or your fault. The burden of proof is on you, even when their infrastructure is clearly misbehaving.
  • Firewalled Experts: The actual SREs and network engineers who can fix the problem are protected by layers of process. You only get access to them if your issue is causing a region-wide outage or you’re a named account like Netflix.

You can’t fix their business model. But you can architect your way around it. Stop trying to get better support; start building systems that don’t need it.

Stop Waiting for a Hero: 3 Ways to Architect for Resilience

If you’re waiting for a support agent to save you during an outage, you’ve already lost. The goal is to design systems where their internal failures become a non-event for you. Here are three strategies we’ve implemented at TechResolve.

1. The “No Single Point of Support” Architecture

We all know about avoiding a single point of failure in our infrastructure. It’s time to apply that same logic to our support vendors. If your entire operation grinds to a halt because Google Cloud Networking in us-central1 is having a bad day and their support is useless, that’s a design flaw.

The Fix: Implement a robust, automated multi-region or even multi-cloud failover strategy. Use a global load balancer (like Cloudflare, Akamai, or AWS Route 53) that isn’t tied to a single provider. If your GKE clusters in GCP start acting up and support is giving you the runaround, a single API call or a health check failure should automatically shift 100% of your traffic to your EKS failover environment in AWS us-east-2.

Old Way (High Risk) Resilient Way (Low Risk)
Single Region GKE deployment. Active-passive GKE and EKS deployments.
DNS points directly to GCP Load Balancer. Cloudflare Global Load Balancing points to both clouds.
Outage Plan: Frantically file a P1 ticket with Google support and wait. Outage Plan: Automated health checks detect GKE latency and fail traffic over to EKS in under 5 minutes. Open a low-priority ticket with Google later.

This isn’t just for disasters. It’s leverage. The ability to completely move off a provider’s troublesome region is more powerful than any support ticket you can write.

2. Your TAM Is Your Bat-Signal (If You Use It Right)

Your Technical Account Manager (TAM) is not an escalation monkey. If you only call them when things are on fire, you’re using them wrong. The support portal is for break-fix; your TAM is your strategic advocate inside the machine.

The Fix: Build a real relationship. Schedule regular architectural reviews. Before a major launch, bring your TAM into the planning phase. Walk them through your concerns. When we were preparing to launch a new service on Spanner, we had three sessions with our Google TAM and a Spanner specialist they brought in. We war-gamed failure scenarios. When a minor latency issue did crop up, our TAM didn’t need to be “brought up to speed”—he already had the context, knew which internal team to ping directly, and bypassed the entire Tier 1 circus for us. Your TAM’s real value is their internal org chart and the social capital they have with the engineering teams. Use it proactively.

3. Prove Them Wrong With Your Own Data

Support’s first line of defense is ambiguity. “We see no issues on our end.” Your job is to eliminate that ambiguity with overwhelming, undeniable data. Don’t give them an escape route.

The Fix: Invest heavily in your observability stack (Prometheus, Grafana, OpenTelemetry, etc.). Your goal is to pinpoint a problem so precisely that it can only have one root cause: them. Don’t open a ticket saying “Our app is slow.”

Open a ticket saying this:

## GKE Egress Latency Anomaly in us-central1-c

Description:
We are observing a sustained 150ms increase in TCP connection handshake time for all egress traffic from our GKE cluster `gke-prod-main-app` in zone `us-central1-c`.

- Start Time: 14:32 UTC
- End Time: Ongoing
- Source: Any pod on GKE nodes with kernel version 5.4.0-1045-gke
- Destination: Any external IP address (tested against 8.8.8.8 and 1.1.1.1)

This issue is NOT present in our identical cluster in `us-central1-b`.

Attached:
1. MTR trace from an affected pod vs. a healthy pod.
2. Grafana dashboard URL showing the exact moment the latency deviation began across all nodes in the zone.
3. Packet capture showing TCP SYN retransmissions.

Please escalate to the regional networking team responsible for the `us-central1-c` data plane. This is not a configuration issue on our end.

When you present a case this airtight, you give the Tier 1 agent no choice but to hit the “escalate” button. You’ve done their job for them. This is how you skip the line.

Darian Vance

👉 Read the original article on TechResolve.blog

Support my work

If this article helped you, you can buy me a coffee:

👉 https://buymeacoffee.com/darianvance

Streamlining Authentication Flows: API Development Under Tight Deadlines for Security Researchers

2026-01-31 07:09:39

Streamlining Authentication Flows: API Development Under Tight Deadlines for Security Researchers

In the fast-paced world of security research, timely and reliable authentication workflows are crucial. When faced with tight deadlines to automate complex authentication flows, developers must rely on rapid API development strategies that are both efficient and secure. This post shares insights from a senior developer's perspective on designing and implementing robust APIs to automate auth flows swiftly.

Understanding the Challenge

Security researchers often work under intense pressure to test vulnerabilities or validate security assumptions, which involves automating user authentication processes. These workflows typically deal with multi-step flows involving OAuth, OpenID Connect, or custom token exchanges—all of which require meticulous handling of tokens, sessions, and secrets.

The primary challenge is to develop APIs that can reliably orchestrate these flows without sacrificing security—often with limited time for extensive testing and iteration.

Rapid API Architecture Design

To meet such demands, adopting a microservice architecture with clear, well-defined endpoints is essential. Focus on building stateless APIs that handle each step independently, enabling easy testing and debugging.

Example: Implementing OAuth 2.0 Token Exchange

Here's a simplified example of an API endpoint that automates the OAuth token refresh flow:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/auth/refresh', methods=['POST'])
def refresh_token():
    refresh_token = request.json.get('refresh_token')
    client_id = 'YOUR_CLIENT_ID'
    client_secret = 'YOUR_CLIENT_SECRET'
    token_url = 'https://provider.com/oauth/token'

    payload = {
        'grant_type': 'refresh_token',
        'refresh_token': refresh_token,
        'client_id': client_id,
        'client_secret': client_secret
    }
    response = requests.post(token_url, data=payload)
    if response.status_code == 200:
        return jsonify(response.json())
    else:
        return jsonify({'error': 'Failed to refresh token'}), response.status_code

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

This API receives a refresh token, requests a new access token from the OAuth provider, and returns it. Encapsulating this logic simplifies complex auth flows during research automation.

Ensuring Security and Reliability

During rapid API development, maintaining security standards is paramount. Employ OAuth best practices:

  • Secure storage of tokens
  • Using HTTPS for all requests
  • Validating inputs rigorously

Additionally, implement retry mechanisms, rate limiting, and logging to ensure API resilience.

Deployment and Testing

Containerize your API with Docker for quick setup:

FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN pip install flask requests
CMD ["python", "app.py"]

Use integration tests to validate auth flows end-to-end. Automated tests using tools like Postman or pytest can simulate multiple scenarios, catching issues early.

Final Thoughts

Rapid API development in security research demands a balance between speed and security. Building modular, secure, and resilient endpoints allows researchers to adapt quickly while maintaining control over critical authentication mechanisms. Incorporating best practices and leveraging lightweight frameworks can dramatically accelerate workflows without compromising security.

This approach allows security teams to stay agile, respond promptly to vulnerabilities, and foster innovation even under tight deadlines.

🛠️ QA Tip

To test this safely without using real user data, I use TempoMail USA.