Bob Galen and Josh Anderson dissect toxic workplace culture and challenge leaders to take ownership. Learn why stack ranking exists (spoiler: because leaders aren't doing their jobs), why brutal AI-driven hiring processes are destroying recruitment, and how to properly use performance improvement plans. Stop passing the buck to HR or the C-suite.
If your workplace is toxic, it's your responsibility to detoxify it. Bob shares his experience refusing to participate in stack ranking, Josh explains why hiring can't be automated, and both hosts deliver their "Make it so" challenge for leaders ready to do the hard work.
Stay Connected and Informed with Our Newsletters
Josh Anderson's "Leadership Lighthouse"
Dive deeper into the world of Agile leadership and management with Josh Anderson's "Leadership Lighthouse." This bi-weekly newsletter offers insights, tips, and personal stories to help you navigate the complexities of leadership in today's fast-paced tech environment. Whether you're a new manager or a seasoned leader, you'll find valuable guidance and practical advice to enhance your leadership skills. Subscribe to "Leadership Lighthouse" for the latest articles and exclusive content right to your inbox.
Bob Galen's "Agile Moose" is a must-read for anyone interested in Agile practices, team dynamics, and personal growth within the tech industry. The newsletter features in-depth analysis, case studies, and actionable tips to help you excel in your Agile journey. Bob brings his extensive experience and thoughtful perspectives directly to you, covering everything from foundational Agile concepts to advanced techniques. Join a community of Agile enthusiasts and practitioners by subscribing to "Agile Moose."
We publish video versions of every episode and post them on our YouTube page.
Help Us Spread The Word:
Love our content? Help us out by sharing on social media, rating our podcast/episodes on iTunes, or by giving to our Patreon campaign. Every time you give, in any way, you empower our mission of helping as many agilists as possible. Thanks for sharing!
In this episode, Ian Griffiths explains how C# 14's new field-back properties feature can save you from metaphorically falling off a cliff when you need more flexibility beyond automatic properties' basic functionality.
He demonstrates the use of this feature to customize property setters without losing the simplicity and support of automatic properties. By allowing you to refer to the compiler-generated field inside get or set methods, C# 14 reduces verbosity and maintains code clarity and organization.
Learn how this small but impactful enhancement can improve your C# coding experience.
00:00 Introduction to C# Shaft 14's New Feature 00:30 Understanding Automatic Properties 01:11 Customizing Property Behavior 03:06 Introducing C# 14's New Syntax 04:21 Benefits of the New Feature 05:33 Conclusion
In this Betatalks episode, Rick and Oscar talk with Yasen Dinkov, an artist turned engineer and head of engineering at Blue10. Yasen shares how his love for visual arts led him to programming and how he sees both art and software as creative acts shaped by imagination and constraints. He explains how his team builds a SaaS platform that uses AI to process documents while blending seamlessly into users’ workflows, focusing on solving real problems rather than following every request. Yasen also reflects on how music and nature inspire his creativity, showing innovation as a journey driven by curiosity and collaboration.
About this episode, and Yasen Dinkov in particular: you can find Yasen on LinkedIn.
Dive into the dynamic world of SwiftUI, SwiftData, and Apple Intelligence in this episode, where we explore how these technologies are transforming development. Join us as we discuss Frank Kruger's innovative work on the Clean Room application, which showcases the elegance of macOS UI design. Discover how AI-driven tools like Apple Intelligence can enhance your Mac's capabilities, offering powerful APIs and translation features that simplify complex tasks. We also delve into the benefits and challenges of using VS Code for Swift development, sharing insights on optimizing Swift projects and leveraging AI for content creation. Perfect for developers and tech enthusiasts, this episode provides actionable takeaways and thought-provoking discussions that will inspire your next project. Tune in to uncover the future of development and productivity!
If you’ve ever had an app crash at the worst possible moment, you’ll know how frustrating it can be - both for developers and players. Recently, I wrote an article for the Microsoft Developer blog that dives deep into this exact challenge: how to diagnose and resolve crashes effectively on Xbox and Windows platforms.
In the post, I share practical tips, tools, and workflows that can help you move quickly and efficiently. Whether you’re building games or apps, these techniques can improve the overall experience for your users.
The problem that Andy described was having a CSS grid with columns of content next to another and then being asked by the client to randomise the order of the grid on every reload. So that each part of the company will get its 3 seconds in the limelight. Andy is a strong believer in resilient code and rightfully is critical of JavaScript solutions for issues like this. Moving a whole DOM construct like this around can be slow and writing out the whole grid as a component on each interaction can also be iffy.
So I pondered what to do and remembered the CSS order property applying to flex and grid items. Using this one, you can re-order items visually.
Excellent bands you never heard about
Irie Revoltes
Streetlight Manifesto
Dubioza Kolektiv
Irish Moutarde
If you change the order of the third element to minus one, it shows up first:
ul {
display: flex;
flex-direction: column;
gap: 1em;
}
This keeps all the re-ordering work in the CSS engine. But as you can’t as yet have random ordering in CSS, we need some JavaScript to create that functionality. The first idea was to add the order as inline styles, but that would be the same DOM manipulation and having to loop through all items. Instead, I thought about using CSS custom properties:
ul {—customorder: -1;
display: flex;
flex-direction: column;
}
The grid above shuffles around on every reload or when you active `shuffle` button. There are many ways to achieve this effect, but this example uses only CSS properties to set the order of the grid items. The HTML is not altered and there is no DOM manipulation other than accessing the CSS properties of the parent element. This should make this highly performant. The JavaScript code rotates the order of the items in the grid by changing the CSS variables that define their order. Below is the relevant code used to set up the grid and shuffle the items:
We define the order of each element as `1`, which means that if we set any of them to `0`, it will be displayed first in the grid. For example, if we did the following, the `Case Studies` section would be displayed first:
This could be done on the server-side or with JavaScript as follows:
let root = document.querySelector(‘#contentgrid’);
let itemcount = getComputedStyle(root).
getPropertyValue(‘—items’);
let old = 1;
const shuffleorder = () => {
let random = Math.floor(Math.random() * itemcount) + 1;
root.style.setProperty(‘—item’ + old + ‘-order’, 1);
root.style.setProperty(‘—item’ + random + ‘-order’, 0);
old = random;
};
shuffleorder();
We get the amount of items in the grid by reading the value of `—items` CSS property on the root element, and store the current first one in the `old` variable. We then pick a random number between `1` and the total number of items, and set the order of the old item to `1` and the new, random, item to `0`. We then re-define `old` as the new item.
This is the most basic way of doing this, and it is not a real shuffle, as it only rotates the items in a fixed order. You can see the Shuffle Grid example for a more advanced implementation as it randomised the array of all the items. You can also rotate the items by shifting the array of all orders as shown in the Rotate Grid example.
The other examples also don’t need any of the custom properties to be set, but create them instead. This means a tad more JS + DOM interaction but makes the process easier.
let root = document.querySelector(‘#contentgrid’);
let cssvar = `—item$x-order`;
// Get the amount of items
let elms = root.querySelectorAll(
root.firstElementChild.tagName
);
all = elms.length;
// Initialize the order array and
// set the order on the items
let orders = [];
for (let i = 1; i <= all; i++) {
orders.push(i);
elms[i – 1].style.setProperty(
‘order’, ‘var(’ + cssvar.replace(‘$x’, i) + ‘)’
);
root.style.setProperty(cssvar.replace(‘$x’, i), i);
}
But what if you wanted to not use any JavaScript at all to achieve this? Andy’s solution he showed during the talk was to randomise the order server-side, which is easy to do in many languages. His solution using Jekyll was to generate the page every few minutes, using the sample filter which seems a bit wasteful, but is stable.
Current and future CSS-only solutions
Currently there is no way to randomise or shuffle items using only CSS. However, there are solutions involving Sass which requires pre-processing. Another nifty solution is this way but it requires the use of `@property` which is not widely supported yet.
Polyfilling CSS isn’t easy, so it might make sense for now to add a dash of JavaScript to your solution to achieve effects like this. This way seems to me a good compromise as it keeps the functionality in CSS instead of shuffling around whole DOM trees or re-writing the whole grid.
Log in
