App Design Layouts

🍱 A Designer’s Guide To Flexbox And CSS Grid (+ Videos) (https://lnkd.in/eX-6F2Ya), a friendly practical guide for designers on how the grid works in the browser, why breakpoints might be unnecessary and how to think about grid and layout when designing in Figma. Neatly put together by Christine Vallaure de la Paz. 👏🏼👏🏽👏🏾 🤔 Designers and developers often understand grid differently. 🤔 Most UIs react to fixed breakpoints based on screen width. 🤔 It makes it necessary to create mock-ups for different widths. ✅ With Flexbox and Grid, UIs can adjust without breakpoints. ✅ Instead, they react and adapt to available content/space. ✅ Flexbox is 1-dimensional ← often used for UI components. ✅ It has 2 elements: parent container and its child elements. ✅ You can control the direction, wrapping, alignment, spacing. ✅ Flexboxes can be nested and set rules to their direct children. ✅ Figma’s auto-layout reflects Flexbox in the Dev Mode. ✅ CSS Grid is 2-dimensional ← used for grids and layout. ✅ It relies on grid lines that set up the grid columns/rows. ✅ We place items across grid lines with coordinates. ✅ Each cell can grow depending on available space. 🚫 You might not need fixed breakpoints for your UIs. The clash between design and technical prototype often happens for one simple reason: there is a mismatch of designer’s expectations of how it should work, and how it technically works under the hood. As designers, we are often allergic to code. We don’t have to know all the technical intricacies — but it’s incredibly useful to understand the material used to actually build those digital experiences that we diligently envision in our design tools. Breakpoints are a good example of that. While we needed them in the past, these days, much of the work can be done with self-contained components that change their appearance depending on where they are on a page. We can use Flexbox, Grid and container queries to allow components to automatically adapt based on their parent. We can use fluid type to allow spacing and font sizes adapt automatically — all without breakpoints. We might need breakpoints for large global changes in layout and grid, but mostly not for component-level changes. There, we can let components flow and scale up and down naturally, within the limitations that we set up for them. Useful resources: Designer's Guide To Container Queries, by Christine https://lnkd.in/e99he_xT Designer’s Guide To Fluid Typography, by Christine https://lnkd.in/egyu3fdg New Front-End Features For Designers In 2025, by Cosima Mielke https://lnkd.in/eDUGbbxe #ux #design

UI designers: this is why Flexbox and CSS Grid actually matter to your daily work. Read on. I wrote a deep dive on modern CSS layout, but here’s the part that’s most relevant if you design in Figma every day: • Auto Layout is basically Flexbox Same mental model. Parent sets the rules, children respond. Direction, spacing, alignment, growth, wrapping, you need to understand it. If something feels “off” in Auto Layout, it will feel off in the browser too. • CSS Grid is not a column grid It’s a two-dimensional layout system built on grid lines and areas. That’s why classic column thinking breaks down so often in dev conversations. • New Figma grid features are closing the gap Fractional units (fr) mixed with fixed. These are the things developers rely on when layouts adapt without endless breakpoints. • The browser behaves, Figma represents What you design is a model. It's getting closer, but it is NEVER as powerful as the browser (I know, I know it's hard hearing this as a Designer). The browser decides how it actually flows when content, screen size, or language changes. So you can be in love with your design but not with the pixel. • This is not about handoff or writing CSS It’s about designing layouts that are possible, flexible, and predictable once they hit real data and real screens. If you understand how Flexbox maps to Auto Layout and how CSS Grid actually works, design-dev conversations get clearer fast. Less “why doesn’t this match Figma” and more “what rules do we want here” and "Let me polish X in Figma and let's see Y in the browser" ✍️ The full article (includes video): https://lnkd.in/dGnvbDSa For more on modern layout, design-dev collaboration, and what’s coming next (container queries included), my free weekly newsletter is where I share the ongoing thinking. ✉️ → Newsletter: moonlearning.io/newsletter
 📚 → All my tutorials: moonlearning.io

High-current DC/DC regulators are often plagued by EMI issues due to high dv/dt and di/dt switching transients during MOSFET commutation. These transients lead to both conducted and radiated EMI, which can severely affect system performance, especially in industries such as automotive and communications, where EMI compliance is crucial. To address this, optimizing the PCB layout is one of the most effective ways to reduce EMI at no extra cost. By carefully designing the power stage layout, engineers can minimize the parasitic inductance of the switching loop, thus reducing voltage overshoot, ringing, and overall EMI emissions. For instance, placing input capacitors close to the MOSFETs, and using a vertically oriented power loop in a multilayer PCB structure can significantly reduce the parasitic loop area. This optimization results in improved EMI performance, lowering the overshoot by up to 4V compared to conventional designs. In this white paper from Texas Instruments, we dive deeper into how specific layout changes can help mitigate EMI for high-current regulators. By leveraging best practices, such as minimizing switching loop area and using high-frequency decoupling capacitors, engineers can enhance system stability and comply with stringent EMI standards more easily.

💡How to design animated transitions Transition animations are key in product design because they guide users from one state to another. Meaningful transitions  ✔ Add animations only if they add meaning to interactions. Any movement, scaling, or motion in your product inherently suggests a direction. ✔ Animations should not distract from important tasks or information. Duration and speed of transition   ✔ Duration of the animation should be slow enough to give users the possibility to notice the change, but at the same time, quick enough not to cause waiting. ✔ Optimal speed for interface animation is between 100 and 500 ms. Transitions that are too slow (>500ms) can bore users, while overly fast transitions (<100ms) will be perceived as instantaneous and won’t be recognized at all. ✔ Duration of transition differs depending on the size of the object and distance. ✔ On mobile devices, Material Design suggests limiting the duration of animation to 200–300 ms.  ✔ For tablets, the duration should be longer by 30% — around 400–450 ms. The size of the screen is bigger, so objects travel longer distances when they change position. Easing curves  ✔ Easing helps to make the movement of the object more natural. For the animation not to look mechanical and artificial, the object should move with acceleration or deceleration. ✔ Ease-in makes animations start slowly and then accelerate towards the end, creating a sensation of gradually picking up speed. This curve should be used when the objects fly out of the screen at full speed. ✔ Ease-out starts animations at a quicker pace and slows down at the end, mimicking the natural deceleration of physical objects. This type of curve should be used when the element emerges on the screen. ✔ Ease-in-out is great for creating realistic movements. This curve makes the objects gain speed at the beginning and then slowly drop back to zero. Choreography ✔ When transitioning multiple elements, rank them by importance to help users focus on key interactions. Instead of transitioning all at once, sequence them by priority. ✔ Group similar items together, then rank these groups. Irrelevant groups can be hidden during the transition to maintain focus on crucial groups. Accessibility ✔ Provide an option to reduce motion effects for users sensitive to motion. ✔ Reduced motion doesn’t not mean mean no motion at all. ✔ Optimize animation for devices with a low refresh rate. 📖 Guides: ✔ The guide to proper use of animation in UI (by Taras Skytskyi)  https://lnkd.in/d4y4b7ds ✔ Transition animations: a practical guide (by Dongkyu Lee)  https://lnkd.in/diYNSFAR ✔ UX Motion + effective duration calculator (by Brainly) https://lnkd.in/eVH8dehQ ✔ Reduced motion for accessibility (by Eric Bailey)  https://lnkd.in/eH3y_Wnb #ui #animations

Most apps don’t fail because of bugs. They fail because they feel cheap. And the crazy part? It usually has nothing to do with features or architecture. It’s the micro-interactions. The tiny moments your users never mention… but always feel. Over the years building mobile apps, I’ve noticed something: You can have perfect code, clean architecture, and zero crashes but if your app feels stiff, sudden, or unresponsive… people will say it “doesn’t feel good,” and they won’t know why. So I put together 3 simple micro-interactions that instantly make an app feel more premium: 1️⃣ Add subtle haptic feedback A tiny vibration makes the interaction feel intentional. 2️⃣ Don’t navigate instantly — bounce first Instant jumps feel raw. A soft bounce gives the UI a human touch. 3️⃣ Don’t let content pop in after shimmer Hard transitions break immersion. Smooth reveals make the UI feel crafted. None of these are big features. None take more than a few minutes to implement. But they change everything about how your app feels. Because premium apps aren’t just coded. They’re crafted. Which micro-interaction do YOU always notice in apps? I want to hear the ones other devs care about. #Flutter #MobileDevelopment #UXDesign #UIUX #Animations #DeveloperExperience #AppDesign #SoftwareEngineering

Cache-Friendly Structs Last week, we conducted a pool, and cache efficiency was one of the most requested topics. I’m really glad this one came up because cache-friendly data structures are one of the most critical factors in modern high-performance systems — and yet, many developers still underestimate how much performance depends on memory layout rather than algorithm complexity. Modern CPUs, such as those designed by Intel, operate at extremely high speeds, but memory access remains relatively slow. To bridge this gap, processors use multiple levels of cache (L1, L2, L3). These caches store small portions of memory closer to the CPU, allowing much faster access compared to main RAM. At first glance, a struct may appear to be just a simple grouping of fields. However, the way fields are ordered and accessed has a direct impact on performance. Struct layout determines how efficiently the CPU cache can load and reuse data. When structs are designed properly, the CPU can fetch useful data in fewer cache lines, reducing latency and improving throughput. To demonstrate why cache-friendly structs matter in practice, consider the core principles that influence performance: Spatial locality — accessing data that is physically close in memory Temporal locality — reusing data that was recently accessed Cache line utilization — maximizing useful data per cache fetch Predictable memory access patterns — enabling hardware prefetching Without these principles, CPUs spend more time waiting on memory than executing instructions. This leads to cache misses, pipeline stalls, and significant performance degradation — especially in systems that process millions of objects per second. In practice, cache-friendly struct design provides something extremely valuable: efficiency. The CPU can load fewer cache lines, reuse more data, and execute instructions continuously without waiting on memory. This is essential in performance-critical environments such as trading systems, real-time engines, and large-scale simulations. One of the biggest strengths of cache-friendly design is that it improves performance without changing algorithms. Simply reorganizing fields can reduce memory stalls and dramatically increase throughput. Below, we included a simple example showing how struct layout directly affects cache efficiency. Even in its minimal form, it illustrates how memory organization impacts performance. And here’s the key takeaway: Cache-friendly structs succeed because they prioritize memory locality, predictability, and efficient cache utilization over convenience. In high-performance systems, memory layout is often more important than algorithm complexity. Struct design provides the foundation that allows modern CPUs to operate at their full potential. Have you ever improved performance significantly just by reorganizing struct fields? #Cpp #LowLatency #CacheFriendly #MemoryManagement #AlgorithmicTrading #EngineeringExcellence #SoftwareArchitecture

🚀 Cache Locality in C++: The Invisible Performance Killer In low-latency requirements, the CPU cache is your true data center. Main memory is hundreds of cycles away — a single cache miss can destroy your latency budget. 💡 A common layout (Array of Structs - AoS): struct Trade { double price; int quantity; char side; // 'B' or 'S' }; std::vector<Trade> trades; This is convenient, but not always cache-efficient. When you access price, the CPU fetches the entire cache line containing that field. If the struct is large or misaligned, unnecessary data (quantity, side) may get pulled in, and fewer useful price values fit in the cache line. ⚡ A cache-friendlier layout (Structure of Arrays - SoA): struct Trades { std::vector<double> prices; std::vector<int> quantities; std::vector<char> sides; }; Here, if your algorithm only touches prices, the cache lines are filled with exactly the data you need — no wasted bandwidth. 🔑 Takeaway: • AoS is convenient, but can waste cache capacity • SoA improves utilization when access patterns are predictable • In HFT, this translates directly into nanoseconds saved per iteration 👉 Next time you design a performance-critical loop, ask yourself: Am I feeding the CPU cache what it needs, or wasting bandwidth? 💭 I’m curious — what’s your favorite technique to get the most out of CPU caches in performance-critical systems? #Cplusplus #Performance #LowLatency #HighFrequencyTrading #SystemDesign

High Current PCB Design: Practical Layout Tips 📍 Designing high-current circuits is not just about increasing trace width. In real projects, current capability depends on layout strategy, copper distribution, and thermal design, therefore PCB layout becomes critical for reliability. Here are some practical approaches: 🟠 Parallel MOSFETs for Higher Current Using multiple MOSFETs in parallel can significantly improve current capacity in half-bridge designs. This allows current sharing and reduces stress on a single device. 🟠 Multi-Layer Copper Distribution For high-current paths: • place MOSFETs on the top layer • use copper pours + vias to connect multiple layers • replicate power copper on inner layers This creates parallel current paths across layers, greatly improving current capacity and reducing resistance. 🟠 Minimize Distance in Half-Bridge Layout In half-bridge design: • place high-side and low-side MOSFETs as close as possible • reduce loop area This improves: ◽ current efficiency ◽ switching performance ◽ EMI behavior 🟠 Use the Right Power Plane Strategy When routing high current: • use power planes (e.g. VM) instead of GND planes for main current paths • maximize copper area connected to the power source The goal is to provide a low-resistance path to the supply 🟠 Increase Copper Thickness Copper thickness directly affects current capability. Typical values: • 1 oz ≈ 35 μm • 2 oz ≈ 70 μm For very high current (e.g. 100A): • use 4 oz copper • increase trace width (e.g. ≥15 mm) • use multi-layer routing + thermal design 🟠 Consider Busbars for Extreme Current For very high current applications: PCB traces may not be enough. In industrial designs (e.g. power systems, servers): • copper busbars are often used • or thick copper / plated structures 🟠 Don't Ignore Return Path Design Current always flows in loops. • low-frequency current → prefers low resistance path • high-frequency current → follows closest return path (minimum inductance) Poor return path design can lead to: ◽ EMI ◽ unstable switching ◽ signal integrity issues 📌 DFM notes High current PCB design is not only about electrical capability. From a manufacturing perspective: • copper balance • via reliability • thermal distribution all affect long-term stability. Small layout differences can lead to significant temperature variation in production. High current design is not just make it wider. It's about: current path + copper distribution + thermal + layout working together #PCBDesign #PowerElectronics #HardwareEngineering #DFM #HighCurrent #ElectronicsEngineering #KnownPCB

Today I want to share some behind the scenes work on how I go from idea to finished page transition. For this one, I wanted a wave of pixels moving across the screen without fully covering it, so both pages stay visible with a pixel wave as the separator. These are the challenges I solved: 1. My first step was stacking both pages and hiding one with a clip-path animation. I used the GSAP steps(12) function to create a stop motion feel linked to the number of pixels per row instead of a smooth transition. 2. Creating 100+ pixel elements by hand was not an option, so I built a helper that duplicates [data-transition-col] and [data-transition-pixel] based on a variable, in my example 12. It calculates how many pixels are needed to fill the screen. Before every transition run it checks the screen size so no resize listener is needed. 3. I started with a simple function animating pixels to opacity 1 randomly and back to 0. This is common, but I wanted to push it into a real wave effect. 4. The hardest part was syncing the clip-path steps with pixels fading randomly from 0 to 1. After lots of iteration I got a version that follows the clip-path edge perfectly. Keeping one line filled hides the page edge. 5. GSAP offers many stagger options. Random does exactly what you expect. Start/end controls direction, in my case per column top to bottom. I also tested center and edges for triangle shapes. Cool, but not the look I wanted. 6. After hours of tweaking and experimenting I nailed the timings, extra pixels, and the key behavior: pixels start first, then the clip-path begins when the wave reaches the edge, pauses, and lets some pixels continue. Everything is controlled with a few tweakable values: const pixelHorizontalAmount = 12; const transitionDuration = 1; const pixelFadeDuration = 0.2; const pixelOverlap = 0.3; Now you are going to ask: what are the last two doing? Pixel Fade Duration: controls how long a column fills. Increasing it makes the spacing feel larger. Pixel Overlap: controls how much pixels fade together, creating softer layered transparency instead of hard flashes. 7. Improving it for portrait devices Portrait screens felt too busy with 12 columns, so instead of complex breakpoints the animation switches direction automatically from left to right to top to bottom. Same values, cleaner result. Time insights 🕓 • 4 hours for the helper function and clip-path • 4 hours tweaking the animation • 2 hours to create this post and video Boilerplate ✨ I used the Osmo Supply boilerplate for the page transition setup. We also have a full Barba.js course showing how to build a One Page Application style site where current and next pages stay visible for transitions like this. This template will be available on Osmo Supply next Monday, so stay tuned. And that’s it! 👋 Hopefully you enjoyed a breakdown like this. If you did, please give this post a like so maybe I make another breakdown!

You can animate without @keyframes. The new @starting-style rule makes it possible. @starting-style lets you define the initial state of an element. CSS then transitions from that state to whatever styles you declare normally. No full animation blocks. No duplicated properties. Just a clean before-and-after transition. The result is simpler code and faster iteration. Perfect for small UI effects like fades, slides, reveals, or subtle micro-interactions. But the real breakthrough is this: You can now animate elements as they enter the DOM. Tooltips. Dropdowns. Modals. Any component that gets inserted dynamically. Before this, CSS had no idea what the “initial” style was. So nothing animated. Developers resorted to JavaScript hacks, forced reflows, or invisible pre-rendered states. @starting-style removes all of that. CSS finally understands the starting point, even if the element wasn’t there a moment earlier. It’s a cleaner, more declarative way to animate UI. Less JavaScript. Better readability. Fewer timing issues. Support is around 88%, so you’ll still need progressive enhancement. But the direction is clear: CSS is becoming more capable on its own. Already tried it? I’d love to hear how you’d use it. **** To learn more tips about CSS, make sure to join my newsletter https://lnkd.in/eemgxQ7M ❤️