📚 Advanced HTML in 5 Minutes
🔖 1. Semantic HTML
Using semantic HTML tags improves SEO and accessibility, as search engines and assistive technologies can better understand the content structure of your page.
⦁ Tags to use:
🔖 2. Meta Tags
Meta tags are crucial for SEO and help create responsive websites. They provide metadata about the HTML document.
⦁ Examples:
🔖 3. Forms
HTML forms allow you to capture user input. HTML5 introduced new input types and attributes for better validation and user experience.
⦁ Example of an advanced form:
🔖 4. Multimedia
You can easily embed audio, video, and images in HTML, enhancing user experience.
⦁ Examples:
🔖 5. SVG
Using Scalable Vector Graphics (SVG) for icons and illustrations ensures that graphics remain sharp at any size.
⦁ Example:
🔖 6. Accessibility
Enhancing web accessibility using ARIA roles and attributes helps better guide users using assistive technologies.
⦁ Examples:
🔖 7. Custom Data Attributes
Custom data attributes help you attach additional information to HTML elements for JavaScript manipulation.
⦁ Example:
🔖 8. HTML Entities
HTML entities allow you to display special characters that are reserved in HTML.
⦁ Examples:
🔖 9. Responsive Images
Using the
⦁ Example:
🔖 10. HTML5 APIs
HTML5 provides powerful APIs such as Geolocation and Local Storage, enhancing the capabilities of web applications.
⦁ Example:
📚 Example Document
Here’s a concise example of an HTML document utilizing advanced HTML features:
This is a quick, advanced overview of HTML features. For mastery, consider diving deeper into each topic!
🔖 1. Semantic HTML
Using semantic HTML tags improves SEO and accessibility, as search engines and assistive technologies can better understand the content structure of your page.
⦁ Tags to use:
<header>, <nav>, <main>, <section>, <article>, <aside>, <footer>
🔖 2. Meta Tags
Meta tags are crucial for SEO and help create responsive websites. They provide metadata about the HTML document.
⦁ Examples:
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="Page description">
🔖 3. Forms
HTML forms allow you to capture user input. HTML5 introduced new input types and attributes for better validation and user experience.
⦁ Example of an advanced form:
<form>
<input type="text" required placeholder="Name">
<input type="email" placeholder="Email">
<input type="date">
<input type="range" min="0" max="100">
<input type="submit" value="Submit">
</form>
🔖 4. Multimedia
You can easily embed audio, video, and images in HTML, enhancing user experience.
⦁ Examples:
<img src="image.jpg" alt="Description" loading="lazy">
<video controls>
<source src="video.mp4" type="video/mp4">
</video>
<audio controls>
<source src="audio.mp3" type="audio/mpeg">
</audio>
🔖 5. SVG
Using Scalable Vector Graphics (SVG) for icons and illustrations ensures that graphics remain sharp at any size.
⦁ Example:
<svg width="100" height="100">
<circle cx="50" cy="50" r="40" fill="blue" />
</svg>
🔖 6. Accessibility
Enhancing web accessibility using ARIA roles and attributes helps better guide users using assistive technologies.
⦁ Examples:
<button aria-label="Close">X</button>
<div role="navigation">...</div>
🔖 7. Custom Data Attributes
Custom data attributes help you attach additional information to HTML elements for JavaScript manipulation.
⦁ Example:
<div data-user-id="123" data-role="admin">User Info</div>
🔖 8. HTML Entities
HTML entities allow you to display special characters that are reserved in HTML.
⦁ Examples:
© & < >
🔖 9. Responsive Images
Using the
srcset attribute in <img> allows browsers to select the appropriate image size for different screen resolutions.⦁ Example:
<img src="image.jpg" srcset="image-2x.jpg 2x, image-3x.jpg 3x" alt="Description">
🔖 10. HTML5 APIs
HTML5 provides powerful APIs such as Geolocation and Local Storage, enhancing the capabilities of web applications.
⦁ Example:
<script>
navigator.geolocation.getCurrentPosition((position) => {
console.log(position.coords.latitude, position.coords.longitude);
});
</script>
📚 Example Document
Here’s a concise example of an HTML document utilizing advanced HTML features:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Advanced HTML</title>
</head>
<body>
<header>
<h1>Welcome</h1>
<nav>
<ul>
<li><a href="#home">Home</a></li>
<li><a href="#about">About</a></li>
</ul>
</nav>
</header>
<main>
<section>
<article>
<h2>Article Title</h2>
<p>Content goes here.</p>
</article>
</section>
</main>
<footer>
<p>© 2025</p>
</footer>
</body>
</html>
This is a quick, advanced overview of HTML features. For mastery, consider diving deeper into each topic!
timurid_map.html
1.7 KB
Approximate territories of the Timurid empire, which historical state do you want a map of?
📜 Web Development Evolution: Past, Present & Future
🕰 1991-2000: The Early Days
🔹 1991 – HTML was created.
🔹 1995 – JavaScript introduced.
🔹 1996 – CSS emerged.
🔹 1999 – HTML 4.01 standardized.
✅ Simple, static sites
❌ No dynamic content
🚀 2000-2010: Dynamic Web Era
🔹 2003 – WordPress launched.
🔹 2004 – AJAX enabled real-time updates.
🔹 2007 – iPhone popularized mobile web.
🔹 2009 – Node.js brought JS to servers.
✅ Interactive sites
❌ Limited mobile support
🤖 2010-2020: Modern Web & AI Boom
🔹 2010 – HTML5 & CSS3 revolutionized UI.
🔹 2013 – React.js made SPAs common.
🔹 2015 – ES6 improved JavaScript.
🔹 2018 – AI chatbots gained traction.
🔹 2020 – WebAssembly enabled high-performance apps.
✅ Mobile-first & AI-driven web
✅ Progressive Web Apps (PWA)
🌍 2025 & Beyond: The Future
🔮 Web3 & Blockchain – Decentralization expands.
🔮 AI-Generated Websites – Auto-built web apps.
🔮 Quantum Computing – Faster & secure cloud apps.
🔮 VR & AR Web – Immersive experiences.
💬 What’s your web dev prediction? Comment below!
🕰 1991-2000: The Early Days
🔹 1991 – HTML was created.
🔹 1995 – JavaScript introduced.
🔹 1996 – CSS emerged.
🔹 1999 – HTML 4.01 standardized.
✅ Simple, static sites
❌ No dynamic content
🚀 2000-2010: Dynamic Web Era
🔹 2003 – WordPress launched.
🔹 2004 – AJAX enabled real-time updates.
🔹 2007 – iPhone popularized mobile web.
🔹 2009 – Node.js brought JS to servers.
✅ Interactive sites
❌ Limited mobile support
🤖 2010-2020: Modern Web & AI Boom
🔹 2010 – HTML5 & CSS3 revolutionized UI.
🔹 2013 – React.js made SPAs common.
🔹 2015 – ES6 improved JavaScript.
🔹 2018 – AI chatbots gained traction.
🔹 2020 – WebAssembly enabled high-performance apps.
✅ Mobile-first & AI-driven web
✅ Progressive Web Apps (PWA)
🌍 2025 & Beyond: The Future
🔮 Web3 & Blockchain – Decentralization expands.
🔮 AI-Generated Websites – Auto-built web apps.
🔮 Quantum Computing – Faster & secure cloud apps.
🔮 VR & AR Web – Immersive experiences.
💬 What’s your web dev prediction? Comment below!
Recent observations have identified an asteroid, designated 2024 YR4, with an unprecedented probability of impacting Earth. NASA's latest assessment indicates a 3.1% chance of collision on December 22, 2032, marking the highest recorded probability for an asteroid of this size
Which HTTP header can prevent clickjacking attacks?
Anonymous Quiz
50%
X-Frame-Options
50%
Content-Security-Policy
0%
Strict-Transport-Security
0%
X-XSS-Protection
What does the 'z-index' property control in CSS?
Anonymous Quiz
100%
Depth positioning of elements
0%
Text alignment
0%
Width of elements
0%
Browser caching
CodePen Blog
Chris’ Corner: onChange
There is an awful lot of change on the web. Sometimes the languages we use to build for the web change. Some of it comes from browsers themselves changing. An awful lot of it comes from ourselves. We change UIs and not always for the better. We build new tools. We see greener grass and we lust after it and chase it.
Marco Rogers calls some of it a treadmill and has a hot take:
A lot of frontend teams are very convinced that rewriting their frontend will lead to the promised land. And I am the bearer of bad tidings.
If you are building a product that you hope has longevity, your frontend framework is the least interesting technical decision for you to make. And all of the time you spend arguing about it is wasted energy.
Personally I wouldn’t cast as harsh of judgement that rewriting a front end is automatically wasted energy. Revisiting code, whatever the circumstances, can have helpful effects, like the person doing it actually understanding it. But I take the point. The success of a product likely has fairly little to do with the front-end framework at play and change for change sake isn’t exactly an efficient way to achieve success.
The web doesn’t just have fits and spurts of change, it’s ever-changing. It’s just the nature of the teams and processes put around specs and browsers and the whole ecosystem really. The cool part about the web platform evolving is that you don’t have to care immediately. The web, gosh bless it, tends to be forgivingly backwards compatible. So staying on top of change largely means taking advantage of things that are easier to do now or a capability that didn’t exist before.
One take on understanding evolving web features is Baseline, which is Google’s take on essentially a badge that shows you how practical it is to use a feature at a glance. Rachel Andrew’s talk Browser Support and The Rapidly Changing Web gets into this, but sadly I haven’t found a video of it yet. I have some critiques of Baseline (namely that it doesn’t help you know if a feature is usable through progressive enhancement or not) but largely it’s a win.
Sometimes changes in a language cause massive sweeping movement. An example of this is the advent of ESM (ECMAScript Modules), that is,
In some situations, sticking with the old actually does come with some cost. For instance, shipping “old” JavaScript (i.e. ES5) is slower, larger, and requires more compilation work. Philip Walton digs into the data there and has a solid conclusion:
Given the data presented in this article, it definitely does not make sense for JavaScript library authors to be transpiling their code to ES5 anymore.
Best case scenario there is to compile code that looks at your chosen browser support targets, so it can evolve as the world does.
Chris’ Corner: onChange
There is an awful lot of change on the web. Sometimes the languages we use to build for the web change. Some of it comes from browsers themselves changing. An awful lot of it comes from ourselves. We change UIs and not always for the better. We build new tools. We see greener grass and we lust after it and chase it.
Marco Rogers calls some of it a treadmill and has a hot take:
A lot of frontend teams are very convinced that rewriting their frontend will lead to the promised land. And I am the bearer of bad tidings.
If you are building a product that you hope has longevity, your frontend framework is the least interesting technical decision for you to make. And all of the time you spend arguing about it is wasted energy.
Personally I wouldn’t cast as harsh of judgement that rewriting a front end is automatically wasted energy. Revisiting code, whatever the circumstances, can have helpful effects, like the person doing it actually understanding it. But I take the point. The success of a product likely has fairly little to do with the front-end framework at play and change for change sake isn’t exactly an efficient way to achieve success.
The web doesn’t just have fits and spurts of change, it’s ever-changing. It’s just the nature of the teams and processes put around specs and browsers and the whole ecosystem really. The cool part about the web platform evolving is that you don’t have to care immediately. The web, gosh bless it, tends to be forgivingly backwards compatible. So staying on top of change largely means taking advantage of things that are easier to do now or a capability that didn’t exist before.
One take on understanding evolving web features is Baseline, which is Google’s take on essentially a badge that shows you how practical it is to use a feature at a glance. Rachel Andrew’s talk Browser Support and The Rapidly Changing Web gets into this, but sadly I haven’t found a video of it yet. I have some critiques of Baseline (namely that it doesn’t help you know if a feature is usable through progressive enhancement or not) but largely it’s a win.
Sometimes changes in a language cause massive sweeping movement. An example of this is the advent of ESM (ECMAScript Modules), that is,
import and export in JavaScript. Seems small — is not small. Particularly because JavaScript also means Node ‘n’ friends, which needed an import mechanism, thus support require() (CJS format) for umpteen years, which is a bit of a different beast. So if you want to support ESM, that’s the future, but it means shipping Node modules in the dual CJS/EMS format, which is annoying work at best. Anthony Fu weighs in here with Move on to ESM-only, a controversial take, but much less so now that Node ships with the ability to require() an ESM file (vice versa would be even more magical). In some situations, sticking with the old actually does come with some cost. For instance, shipping “old” JavaScript (i.e. ES5) is slower, larger, and requires more compilation work. Philip Walton digs into the data there and has a solid conclusion:
Given the data presented in this article, it definitely does not make sense for JavaScript library authors to be transpiling their code to ES5 anymore.
Best case scenario there is to compile code that looks at your chosen browser support targets, so it can evolve as the world does.
lea.verou.me
Minimalist Affordances: Making the right tradeoffs • Lea Verou
Usability and aesthetics usually go hand in hand. In fact, there is even what we call the “Aesthetic Usability Effect”: users perceive beautiful interfaces as easier to use and cut them more slack when it comes to minor usability issues. Unfortunately, sometimes…
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Speed of Light Measurement</title>
</head>
<body>
<h1>Measuring the Speed of Light</h1>
<button onclick="startMeasurement()">Start Measurement</button>
<p id="result">Waiting for measurement...</p>
<video id="camera" autoplay></video>
<script>
let video = document.getElementById("camera");
async function startMeasurement() {
try {
// Start camera
let stream = await navigator.mediaDevices.getUserMedia({ video: true });
video.srcObject = stream;
video.play();
let startTime = performance.now(); // Start timing
// Monitor brightness increase
let canvas = document.createElement("canvas");
let ctx = canvas.getContext("2d");
let brightnessDetected = false;
function checkBrightness() {
if (!brightnessDetected) {
ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
let frame = ctx.getImageData(0, 0, canvas.width, canvas.height);
let brightness = frame.data.reduce((a, b) => a + b) / frame.data.length;
if (brightness > 200) { // Light detected
let endTime = performance.now();
let timeTaken = (endTime - startTime) / 1000; // Convert to seconds
let distance = 2; // Distance in meters
let speedOfLight = (2 * distance) / timeTaken;
document.getElementById("result").innerText = `Speed of Light: ${speedOfLight.toFixed(2)} m/s`;
brightnessDetected = true;
} else {
requestAnimationFrame(checkBrightness);
}
}
}
requestAnimationFrame(checkBrightness);
} catch (error) {
console.error("Camera access denied:", error);
}
}
</script>
</body>
</html>
📚 1. Python
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development, data analysis, machine learning, scripting
⦁ Key Features: Easy readability, extensive libraries (e.g., NumPy, Pandas), strong community support.
📚 2. JavaScript
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development (frontend and backend), server-side applications (Node.js)
⦁ Key Features: Event-driven, prototype-based, supports asynchronous programming.
📚 3. Java
⦁ Type: High-level, compiled (to bytecode)
⦁ Use Cases: Enterprise applications, Android app development, backend systems
⦁ Key Features: Object-oriented, platform-independent (Java Virtual Machine), strong typing.
📚 4. C++
⦁ Type: Middle-level, compiled
⦁ Use Cases: System/software development, game development, performance-critical applications
⦁ Key Features: Object-oriented, low-level memory manipulation, templates for generic programming.
📚 5. C#
⦁ Type: High-level, compiled
⦁ Use Cases: Windows applications, game development (Unity), enterprise applications
⦁ Key Features: Object-oriented, integrates well with .NET framework, strong typing.
📚 6. Ruby
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development (Ruby on Rails), scripting
⦁ Key Features: Highly readable syntax, dynamic typing, focus on developer happiness.
📚 7. Go (Golang)
⦁ Type: High-level, compiled
⦁ Use Cases: Cloud services, distributed systems, microservices
⦁ Key Features: Concurrency support (goroutines), simplicity and clarity, strong standard library.
📚 8. Swift
⦁ Type: High-level, compiled
⦁ Use Cases: iOS and macOS development
⦁ Key Features: Type-safe, modern syntax, performance-oriented.
📚 9. PHP
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development, server-side scripting
⦁ Key Features: Easy integration with HTML, extensive use in web frameworks like Laravel.
📚 10. Rust
⦁ Type: High-level, compiled
⦁ Use Cases: System programming, performance-critical applications, safe concurrency
⦁ Key Features: Memory safety without garbage collection, strong static typing, modern syntax.
📚 11. Kotlin
⦁ Type: High-level, compiled
⦁ Use Cases: Android app development, server-side applications
⦁ Key Features: Interoperable with Java, concise syntax, null safety.
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development, data analysis, machine learning, scripting
⦁ Key Features: Easy readability, extensive libraries (e.g., NumPy, Pandas), strong community support.
📚 2. JavaScript
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development (frontend and backend), server-side applications (Node.js)
⦁ Key Features: Event-driven, prototype-based, supports asynchronous programming.
📚 3. Java
⦁ Type: High-level, compiled (to bytecode)
⦁ Use Cases: Enterprise applications, Android app development, backend systems
⦁ Key Features: Object-oriented, platform-independent (Java Virtual Machine), strong typing.
📚 4. C++
⦁ Type: Middle-level, compiled
⦁ Use Cases: System/software development, game development, performance-critical applications
⦁ Key Features: Object-oriented, low-level memory manipulation, templates for generic programming.
📚 5. C#
⦁ Type: High-level, compiled
⦁ Use Cases: Windows applications, game development (Unity), enterprise applications
⦁ Key Features: Object-oriented, integrates well with .NET framework, strong typing.
📚 6. Ruby
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development (Ruby on Rails), scripting
⦁ Key Features: Highly readable syntax, dynamic typing, focus on developer happiness.
📚 7. Go (Golang)
⦁ Type: High-level, compiled
⦁ Use Cases: Cloud services, distributed systems, microservices
⦁ Key Features: Concurrency support (goroutines), simplicity and clarity, strong standard library.
📚 8. Swift
⦁ Type: High-level, compiled
⦁ Use Cases: iOS and macOS development
⦁ Key Features: Type-safe, modern syntax, performance-oriented.
📚 9. PHP
⦁ Type: High-level, interpreted
⦁ Use Cases: Web development, server-side scripting
⦁ Key Features: Easy integration with HTML, extensive use in web frameworks like Laravel.
📚 10. Rust
⦁ Type: High-level, compiled
⦁ Use Cases: System programming, performance-critical applications, safe concurrency
⦁ Key Features: Memory safety without garbage collection, strong static typing, modern syntax.
📚 11. Kotlin
⦁ Type: High-level, compiled
⦁ Use Cases: Android app development, server-side applications
⦁ Key Features: Interoperable with Java, concise syntax, null safety.
Here are five advanced JavaScript techniques that can help enhance your coding skills and make your applications more efficient and maintainable:
📚 1. Closures
Closures are a function that retains access to its lexical scope, even when the function is executed outside that lexical scope. This feature can be used for data encapsulation, creating private variables, and implementing callback functions.
Example:
📚 2. Promises and Async/Await
Promises and the async/await syntax provide a powerful way to handle asynchronous operations in JavaScript. Promises represent a value that may be available now, or in the future, or never. Async/await provides a more synchronous way to work with promises for better readability.
Example:
📚 3. Higher-Order Functions
Higher-order functions are functions that take other functions as arguments or return functions as their results. They are fundamental to functional programming in JavaScript.
Example:
📚 4. Module Pattern
The Module Pattern is used to create private and public members in JavaScript, helping to organize code and maintain encapsulation. It uses closures to keep variables private while exposing public methods.
Example:
📚 5. Debouncing and Throttling
Debouncing and throttling are techniques to control the rate at which a function is executed, useful for optimizing performance, especially in event-driven environments.
⦁ Debouncing ensures a function runs only after a certain period of inactivity.
Example of Debouncing:
⦁ Throttling ensures a function executes at most once in a specified period.
Example of Throttling:
These techniques are essential for creating efficient, maintainable, and scalable JavaScript code, particularly in larger applications. Understanding and applying these concepts will significantly enhance your JavaScript programming skills.
📚 1. Closures
Closures are a function that retains access to its lexical scope, even when the function is executed outside that lexical scope. This feature can be used for data encapsulation, creating private variables, and implementing callback functions.
Example:
function makeCounter() {
let count = 0;
return function() {
count += 1;
return count;
};
}
const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2
📚 2. Promises and Async/Await
Promises and the async/await syntax provide a powerful way to handle asynchronous operations in JavaScript. Promises represent a value that may be available now, or in the future, or never. Async/await provides a more synchronous way to work with promises for better readability.
Example:
function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve("Data received!");
}, 1000);
});
}
async function getData() {
const result = await fetchData();
console.log(result);
}
getData(); // After 1 second, "Data received!" will be logged
📚 3. Higher-Order Functions
Higher-order functions are functions that take other functions as arguments or return functions as their results. They are fundamental to functional programming in JavaScript.
Example:
function map(arr, callback) {
const result = [];
for (let i = 0; i < arr.length; i++) {
result.push(callback(arr[i], i, arr));
}
return result;
}
const nums = [1, 2, 3];
const squares = map(nums, x => x * x);
console.log(squares); // [1, 4, 9]
📚 4. Module Pattern
The Module Pattern is used to create private and public members in JavaScript, helping to organize code and maintain encapsulation. It uses closures to keep variables private while exposing public methods.
Example:
const Module = (function() {
let privateVar = 'I am private';
return {
publicMethod: function() {
console.log(privateVar);
},
};
})();
Module.publicMethod(); // "I am private"
📚 5. Debouncing and Throttling
Debouncing and throttling are techniques to control the rate at which a function is executed, useful for optimizing performance, especially in event-driven environments.
⦁ Debouncing ensures a function runs only after a certain period of inactivity.
Example of Debouncing:
function debounce(func, wait) {
let timeout;
return function() {
clearTimeout(timeout);
timeout = setTimeout(() => func.apply(this, arguments), wait);
};
}
const handleResize = debounce(() => {
console.log('Window resized!');
}, 200);
window.addEventListener('resize', handleResize);
⦁ Throttling ensures a function executes at most once in a specified period.
Example of Throttling:
function throttle(func, limit) {
let lastFunc;
let lastRan;
return function() {
const context = this;
const args = arguments;
if (!lastRan) {
func.apply(context, args);
lastRan = Date.now();
} else {
clearTimeout(lastFunc);
lastFunc = setTimeout(function() {
if ((Date.now() - lastRan) >= limit) {
func.apply(context, args);
lastRan = Date.now();
}
}, limit - (Date.now() - lastRan));
}
};
}
const log = throttle(() => {
console.log('Throttled function executed');
}, 1000);
window.addEventListener('scroll', log);
These techniques are essential for creating efficient, maintainable, and scalable JavaScript code, particularly in larger applications. Understanding and applying these concepts will significantly enhance your JavaScript programming skills.
CodePen Blog
Chris’ Corner: Color Accessibility
I’ve been a bit sucked into the game Balatro lately. Seriously. Tell me your strategies. I enjoy playing it equally as much lately as unwinding watching streamers play it on YouTube. Balatro has a handful of accessibility features. Stuff like slowing down or turning off animations and the like. I’m particularly interested one of the checkboxes below though: https://blog.codepen.io/wp-content/uploads/2025/02/image-1024x471.png “High Contrast Cards” is one of the options. It’s a nice option to have, but I find it particularly notable because of it’s popularity. You know those streamers I mentioned? The all seem to have this option turned on. Interesting how an “accessibility feature” actually seems to make the game better for everybody. As in, maybe the default should be reversed or just not there at all, with the high contrast version being just how it is.
It reminds me about how half of Americans, particularly the younger generation, prefer having closed captioning on TV some or all of the time. An accessibility feature that they just prefer.
Interestingly, the high contrast mode in Balatro mostly focuses on changing colors. https://blog.codepen.io/wp-content/uploads/2025/02/image-1-1024x471.png If you don’t suffer from any sort of colorblindness (like me? I think?) you’ll notice the clubs above are blue, which differentiates them from the spades which remain black. The hearts and clubs are slightly differentiated with the diamonds being a bit more orange than red.
Is that enough? It’s enough for many players preferring it, likely preventing accidentally playing a flush hand with the wrong suits, for example. But I can’t vouch for if it works for people with actual low vision or a type of color blindness, which is what I’d assume would be the main point of the feature. Andy Baio wrote a memorable post about colorblindness a few years ago called Chasing rainbows. There are some great examples in that post that highlight the particular type of colorblindness Andy has. Sometimes super different colors look a lot closer together than you’d expect, but still fairly distinct. Where sometimes two colors that are a bit different actually appear identical to Andy. https://blog.codepen.io/wp-content/uploads/2025/02/Screenshot-2025-02-24-at-7.57.24 AM-1024x679.png So maybe the Balatro colors are enough (lemme know!) or maybe they are not. I assume that’s why a lot of “high contrast” variations do more than color, they incorporate different patterns and whatnot. Which, fair enough, the playing cards of Balatro already do.
Let’s do a few more fun CSS and color related links to round out the week:
* Adam Argyle: A conic gradient diamond and okLCH — I’m always a little surprised at the trickery that conic gradients unlock. Whenever I think of them I’m like uhmmmmm color pickers and spinners I guess?
* Michelle Barker: Messing About with CSS Gradients — Layered gradients unlocking some interested effects and yet more trickery.
* Michelle Barker: Creating color palettes with the CSS color-mix() function — Sure,
* Keith Grant: Theme Machine — A nice take on going from choosing nice individual colors to crafting palettes, seeing them in action, and getting custom property output for CSS.
Chris’ Corner: Color Accessibility
I’ve been a bit sucked into the game Balatro lately. Seriously. Tell me your strategies. I enjoy playing it equally as much lately as unwinding watching streamers play it on YouTube. Balatro has a handful of accessibility features. Stuff like slowing down or turning off animations and the like. I’m particularly interested one of the checkboxes below though: https://blog.codepen.io/wp-content/uploads/2025/02/image-1024x471.png “High Contrast Cards” is one of the options. It’s a nice option to have, but I find it particularly notable because of it’s popularity. You know those streamers I mentioned? The all seem to have this option turned on. Interesting how an “accessibility feature” actually seems to make the game better for everybody. As in, maybe the default should be reversed or just not there at all, with the high contrast version being just how it is.
It reminds me about how half of Americans, particularly the younger generation, prefer having closed captioning on TV some or all of the time. An accessibility feature that they just prefer.
Interestingly, the high contrast mode in Balatro mostly focuses on changing colors. https://blog.codepen.io/wp-content/uploads/2025/02/image-1-1024x471.png If you don’t suffer from any sort of colorblindness (like me? I think?) you’ll notice the clubs above are blue, which differentiates them from the spades which remain black. The hearts and clubs are slightly differentiated with the diamonds being a bit more orange than red.
Is that enough? It’s enough for many players preferring it, likely preventing accidentally playing a flush hand with the wrong suits, for example. But I can’t vouch for if it works for people with actual low vision or a type of color blindness, which is what I’d assume would be the main point of the feature. Andy Baio wrote a memorable post about colorblindness a few years ago called Chasing rainbows. There are some great examples in that post that highlight the particular type of colorblindness Andy has. Sometimes super different colors look a lot closer together than you’d expect, but still fairly distinct. Where sometimes two colors that are a bit different actually appear identical to Andy. https://blog.codepen.io/wp-content/uploads/2025/02/Screenshot-2025-02-24-at-7.57.24 AM-1024x679.png So maybe the Balatro colors are enough (lemme know!) or maybe they are not. I assume that’s why a lot of “high contrast” variations do more than color, they incorporate different patterns and whatnot. Which, fair enough, the playing cards of Balatro already do.
Let’s do a few more fun CSS and color related links to round out the week:
* Adam Argyle: A conic gradient diamond and okLCH — I’m always a little surprised at the trickery that conic gradients unlock. Whenever I think of them I’m like uhmmmmm color pickers and spinners I guess?
* Michelle Barker: Messing About with CSS Gradients — Layered gradients unlocking some interested effects and yet more trickery.
* Michelle Barker: Creating color palettes with the CSS color-mix() function — Sure,
color-mix() is nice for a one-off where you’re trying to ensure contrast or build the perfect combo from an unknown other color, but it can also be the foundational tool for a system of colors.* Keith Grant: Theme Machine — A nice take on going from choosing nice individual colors to crafting palettes, seeing them in action, and getting custom property output for CSS.
Fascinating Facts About Web Development 🌍💻
1️⃣ The First Website Still Exists!
Tim Berners-Lee, the inventor of the World Wide Web, created the first website in 1991. You can still visit it here: info.cern.ch.
2️⃣ HTML is Not a Programming Language
Unlike JavaScript or Python, HTML is a markup language—it structures content but doesn’t perform logic-based operations.
3️⃣ JavaScript Runs Everywhere
Initially designed for web browsers, JavaScript is now used for server-side development (Node.js), mobile apps, AI, and even game development.
4️⃣ CSS Can Animate Without JavaScript
With CSS animations and transitions, you can create smooth effects without writing a single line of JavaScript.
5️⃣ The Web Has Over 1.5 Billion Websites
However, only about 200 million are actively maintained. The rest are inactive or abandoned.
6️⃣ Google Ranks Speed as a Factor
Websites that load faster than 2 seconds have a better chance of ranking higher on Google. Performance is key!
7️⃣ Most Users Leave a Slow Website in 3 Seconds
If your website takes too long to load, visitors will bounce—meaning they leave before interacting.
8️⃣ Mobile-First is the New Standard
More than 60% of web traffic comes from mobile devices, so responsive design isn’t optional—it’s essential.
9️⃣ Dark Mode Saves Battery
On OLED screens, dark mode can reduce power consumption by up to 60%, making it both stylish and energy-efficient.
🔟 Hackers Attack Every 39 Seconds
Security is crucial in web development. Using HTTPS, secure passwords, and firewalls helps protect websites from attacks.
Which fact surprised you the most? 🚀
1️⃣ The First Website Still Exists!
Tim Berners-Lee, the inventor of the World Wide Web, created the first website in 1991. You can still visit it here: info.cern.ch.
2️⃣ HTML is Not a Programming Language
Unlike JavaScript or Python, HTML is a markup language—it structures content but doesn’t perform logic-based operations.
3️⃣ JavaScript Runs Everywhere
Initially designed for web browsers, JavaScript is now used for server-side development (Node.js), mobile apps, AI, and even game development.
4️⃣ CSS Can Animate Without JavaScript
With CSS animations and transitions, you can create smooth effects without writing a single line of JavaScript.
5️⃣ The Web Has Over 1.5 Billion Websites
However, only about 200 million are actively maintained. The rest are inactive or abandoned.
6️⃣ Google Ranks Speed as a Factor
Websites that load faster than 2 seconds have a better chance of ranking higher on Google. Performance is key!
7️⃣ Most Users Leave a Slow Website in 3 Seconds
If your website takes too long to load, visitors will bounce—meaning they leave before interacting.
8️⃣ Mobile-First is the New Standard
More than 60% of web traffic comes from mobile devices, so responsive design isn’t optional—it’s essential.
9️⃣ Dark Mode Saves Battery
On OLED screens, dark mode can reduce power consumption by up to 60%, making it both stylish and energy-efficient.
🔟 Hackers Attack Every 39 Seconds
Security is crucial in web development. Using HTTPS, secure passwords, and firewalls helps protect websites from attacks.
Which fact surprised you the most? 🚀