标签：#framework

A lot of Robot Framework projects still look like plain Selenium scripts with .robot file extensions. Someone imports webdriver , creates driver = webdriver.Chrome() , then calls find_element and send_keys in Python helpers. Robot Framework runs the suite, but readable keywords, shared libraries, and consistent waits never show up in the tests. If you already use Robot Framework with SeleniumLibrary , you do not need the raw WebDriver API. SeleniumLibrary gives you high-level keywords. The Page Object Model gives you structure. Together they keep tests short and UI changes localized. We published a small MIT template that shows the layout: rf-seleniumlibrary-pageobject-template . It targets Sauce Demo — clone it, run four tests, fork the folder structure. What breaks when you mix in raw WebDriver driver = webdriver . Chrome () driver . find_element ( By . ID , " user-name " ). send_keys ( " standard_user " ) driver . find_element ( By . ID , " password " ). send_keys ( " secret_sauce " ) driver . find_element ( By . ID , " login-button " ). click () Fine for a script. Painful in a growing suite. Locators spread across helpers and test files. Waits become time.sleep(2) in one place and missing in another. You end up maintaining SeleniumLibrary and a parallel WebDriver stack. CI fails on a Tuesday night and you are not sure which path opened the browser. Before and after Before After driver.find_element(...).send_keys(...) Login With Valid Credentials ${VALID_USER} ${VALID_PASSWORD} Locators in every file LoginLocators.USERNAME in one module Ad-hoc sleeps wait_until_element_is_visible in BasePage.click() Two browser stacks One SeleniumLibrary instance per suite Four layers Layer Job Example Locators Selectors per screen login_locators.py BasePage Shared waits and actions click() , enter_text() Page library Screen keywords LoginPage.login() Robot test Scenario only Inventory Should Be Visible Folder layout in the repo: resources/locators/ → selectors pages/ → Python pa

Introduction: Unveiling littlebag Meet littlebag , a reactive UI framework that defies conventional expectations by packing essential features into a mere 343 bytes (minified and brotlified). This isn’t just a technical curiosity—it’s a proof of concept that challenges the notion that UI frameworks must be bloated to be functional. littlebag includes: Reactive state management via state and effect , enabling dynamic updates without manual DOM manipulation. An html element factory that inherently supports reactivity, reducing boilerplate code. Conditional rendering with keyed , allowing efficient updates to specific UI segments. Reactive lists using each , simplifying the handling of dynamic data collections. TypeScript declarations , ensuring type safety and developer productivity. The framework’s size is achieved through aggressive tree-shaking and code minimization , stripping away all non-essential logic. However, this comes at a cost: performance limitations due to the absence of optimizations like virtual DOM diffing or batch updates . Each reactive update triggers direct DOM manipulation, which can lead to layout thrashing —a mechanical process where frequent reflows and repaints cause frame rate drops, making the UI feel sluggish. Inspired by VanJS (1 kB) and its dependency on an additional 1.2 kB library (Van X), littlebag aims to eliminate such overhead. Yet, its current state is experimental. Without user feedback, it risks remaining a niche project, failing to address its performance bottlenecks or evolve into a viable alternative to larger frameworks. The creator’s plan to add Server-Side Rendering (SSR) hinges on community interest, but SSR itself introduces complexity—requiring a custom DOM implementation to avoid client-side hydration costs. If users engage, littlebag could become a lightweight SSR solution; if not, it may stagnate as a curiosity. The stakes are clear: littlebag’s utility depends on whether it can balance its minimalism with practical

In this eMag, we try to establish agentic AI architecture as a new type of software architecture that will likely dominate the industry for years to come. The articles, written by industry experts, cover various elements and aspects of agentic AI architecture. We aim to present the latest trends and developments shaping the new type of architecture as it enters the mainstream. By InfoQ

Hey dev.to community! 👋 Over the last few months, juggling my roles as a Project Manager, Scrum Master, and lead for QA, Support, and Documentation has been a wild ride. The sheer speed of "vibe coding"—a paradigm shift where the primary role of the developer transitions from manual code construction to high-level intent orchestration—is incredible. Tools like Cursor, Replit Agent, and Google Antigravity allow us to scaffold entire microservices in minutes. However, while this transition offers unprecedented generative velocity, it introduces systemic risks concerning architectural integrity, long-term maintainability, and security. That’s why I’m sharing Cronos (Version 2.0) : a new, strategic methodology I’ve formalized for human-validated vibe coding and agentic software engineering. Real-World Testing & The Multi-Track Approach We have been rigorously testing this framework with our team over the last three months. The empirical results have been fantastic, tracking closely with the framework's theoretical efficiency models to deliver an almost 4x gain in productivity. To maintain production stability while achieving this speed, we adopted a multi-track approach. We continue to use standard Scrum for our maintenance track, which handles smaller tasks, support requests, and standard bug fixes. Meanwhile, Cronos is deployed exclusively for our parallel feature track, tackling larger Epics and new feature development. This ensures production stability does not stall innovation velocity. What is Cronos? The genesis of Cronos lies in the recognition that traditional Agile methodologies often fail to keep pace with the collapsed feedback loops of AI-driven development. In the current agentic era, the bottleneck has shifted from implementation to validation and strategic alignment. Cronos reconfigures the software development lifecycle (SDLC) around one-week "Cycles". Each cycle is a burst of high-intensity, AI-augmented creation coupled with a fixed duration of human

Stop Asking 'Is GAI Here' — Ask 'At What Layer' The GAI debate has a structural problem. Someone says "passing this benchmark means GAI." A model passes it. Then they say "that benchmark wasn't hard enough." The goalpost moves. Someone says "passing the Turing test means GAI." Models pass it. Then they say "the Turing test is too easy." The goalpost moves again. Someone says "inventing new mathematics means GAI." Models do it. Then they say "that's just pattern matching in disguise." Goalpost moves. This isn't bad faith. It's a missing layer definition. We never agreed on what "general" means. Without that, every achievement gets reclassified as "not really general." I've been working on a framework that might fix this. It started as a capability map. Then I realized: this isn't just a map. It's a GAI maturity model. The Five Layers Layer Name Definition L0 Embodied Perceive and operate in the physical world L1 Application Complete single-domain tasks using tools L2 Engineering Build and maintain systems L3 Meta-Domain Abstract and transfer between unrelated domains L4 Meta-Cognition Perceive and control your own thinking process The rule: layers cannot be skipped. It's a maturity sequence, not a checklist. This immediately explains the goalpost problem: some people define GAI as L1. Others define it as L4. They're using different layers for the same word. What About Models Without Bodies? L0 requires embodiment. Text-only models don't have bodies. The cleanest answer: LLMs have no L0. They start at L1 — cognition without embodiment. This isn't a defect. It's an architectural difference. Humans build up from L0 (a baby senses the world before understanding it). LLMs start at L1 (they understand the world directly, skipping physical experience). The result: humans can "feel" when something is wrong — that's L0 feeding signals up to L4. LLMs don't have this channel. The framework forced me to face something uncomfortable: human intelligence cannot exist without a body

Props for That creates live props based things CSS can't normally see in the browser. Things like cursor position, progress values, certain form states, current time, scroll velocity. Prop For That originally handwritten and published with love on CSS-Tricks . You should really get the newsletter as well.

Here's a question most businesses never think to ask when they're building a website: can everyone actually use this? Not just the people on a fast laptop with perfect vision and a reliable internet connection. Everyone. The person navigating your site with a screen reader because they're visually impaired. The user who can't use a mouse and relies entirely on a keyboard. The individual with a cognitive disability who needs clear, consistent layouts to make sense of what they're looking at. If your website doesn't work for these people, it doesn't work full stop. And yet, accessibility is almost always the last thing discussed in a web development project, usually buried somewhere at the bottom of a checklist, treated as a nice-to-have instead of a requirement. That needs to change. Not because of legal compliance (though that's a real consideration too), but because accessibility-first web development simply produces better websites. Faster load times, cleaner code, better SEO, higher user retention accessible design delivers all of that. The framework isn't complicated. It just requires thinking about it from the start instead of trying to bolt it on at the end. This is that framework. What Accessibility-First Web Development Actually Means Accessibility-first is a mindset, not a checklist. It means building with the full range of human experience in mind from day one not auditing for compliance after the site is already live. It's Not the Same as Compliance WCAG (Web Content Accessibility Guidelines) is the global standard for web accessibility. Most businesses know it exists. Very few understand what it actually requires or that meeting WCAG 2.1 AA standards isn't a ceiling, it's a floor. Compliance means you passed the audit. Accessibility-first means you thought about disabled users during architecture decisions, during design reviews, during content writing, and during QA. Compliance is a document. Accessibility-first is a process. The gap between the two mat

PageSpeed Insights had been staring at me for weeks. Desktop was holding at 91. Mobile was stuck at 63. I'd already fixed the obvious stuff — non-blocking fonts, preconnects, fetchpriority on the hero image. But there it was, every single run: Improve image delivery — Est savings of 985 KiB Nearly a megabyte of wasted transfer, just from six project screenshots. And that was just the images visible above the fold. The full list across all projects was worse. The culprit: every image I'd ever uploaded through the Django admin was a PNG. Some of them were over 1 MB. WebP would have cut most of them by 80%. I knew this. I just hadn't done anything about it. So I wrote a management command to fix the backlog, and then made the model auto-convert on every future upload so I'd never have to think about it again. The Problem With PNGs in a Portfolio When you're building a portfolio, you screenshot your work and drag it into the admin. That screenshot is usually a PNG — lossless, full-size, straight from your display. Nobody optimises it because the admin accepts it and it shows up fine in the browser. But "shows up fine" isn't the same as "loads fast." A 1.4 MB PNG of a law firm homepage does not need to be 1.4 MB. Served as WebP at quality 85, it's 175 KB. Same visual result. Eight times smaller. Multiply that across 28 projects and you're looking at tens of megabytes that mobile users on slow 4G are downloading just to scroll past thumbnails. The One-Time Backlog Fix: A Management Command First, I needed a way to convert everything that was already in S3. A management command was the right tool — it runs in the production container with full access to the Django ORM and the configured storage backend, so it can read and rewrite files without needing to know whether they're on S3, local disk, or anywhere else. # backend/projects/management/commands/convert_images_to_webp.py from io import BytesIO from django.core.files.base import ContentFile from django.core.management.b