Jonathan Creamer

While we're talking about web history, did you know the first server-side scripting language widely used was Common Gateway Interface (CGI) scripts, often written in Perl? It paved the way for dynamic web content before languages like PHP, ASP, and JSP became prevalent. Pretty cool how far we've come! JavaScript Mastery #WebDevelopment #TechFacts #CGI #ProgrammingHistory #DSA, #DataStructures, #Algorithms, #Python, #PythonProgramming, #Coding, and #Programming #datastructures #programming #coding #programmer #algorithm #java #datastructure #python #javascript #coder #computerscience #algorithms #datastructuresandalgorithms #codinglife #coders #webdevelopment #software #dsa #codingbootcamp #developer #learn #programmers #softwaredeveloper #datascience #technology #with #programminglife #re #programmingmemes #html #meme

1,733

24 Comments

Anthropic has taken many of the core concepts of Claude Flow and integrated them directly into its new Claude Agent SDK. In my Flow platform, I had to build orchestration around features like artifact tracking, retries, and context persistence because the SDK didn’t provide them. Now those same ideas are native. Tool governance, artifact durability, and context checkpoints are primitives in the SDK. For example, in Claude Flow I wrote custom routines to retry failed tool calls with exponential backoff. The SDK now includes built-in retry handling. I built artifact management so outputs could be stored, versioned, and reused. The SDK now provides artifact durability out of the box. I had to wire in checkpoints to let an agent recover from mid-flow errors. The SDK now exposes context checkpoints directly. This validates the Flow approach. Structured cycles weren’t a workaround, they were the correct abstraction. Developers can now spin up long-running agents without bolting on any orchestration. The friction is lower, the foundation is stronger. At the same time, Anthropic is absorbing practices we pioneered back into its stack. Not that they have given any acknowledgement. Subagents? That was literally our term. The good news is this makes agents easier for newcomers to build, but it also sets tighter boundaries on how Claude agents are expected to work.

181

33 Comments

I am sharing my perspectives on things to avoid in software architecture design reviews. As someone who’s spent years in the trenches of software architecture, I’ve learned that what you don’t do is just as important as what you do. Here are key pitfalls to steer clear of: ✅ Over-indexing on perfection Architecture is about trade-offs. Seeking the “perfect” design can stall progress and demoralize teams. Focus on what’s fit for purpose. ✅ Ignoring context A design that works for one team or product may not scale or align with another. Always ask: What constraints, goals, and timelines shape this solution? ✅ Dominating the conversation Senior engineers should guide, not dictate. Create space for younger voices and diverse perspectives—they often surface blind spots. ✅ Skipping the “why” Reviewing what was built without understanding why it was built that way misses the point. Ask about the rationale behind decisions. ✅ Neglecting non-functional requirements Scalability, security, observability, and maintainability aren’t optional. They’re foundational. Don’t let them be an afterthought. ✅ Focusing only on the tech Architecture is as much about people and processes as it is about systems. Consider team maturity, deployment models, and operational realities. ✅ Failing to document outcomes A review without clear takeaways is a missed opportunity. Capture decisions, action items, and follow-ups for accountability and learning. Great architecture reviews are collaborative, contextual, and constructive. Let’s raise the bar—by knowing what to avoid. #SoftwareArchitecture #EngineeringLeadership #DesignReview #TechStrategy #SeniorEngineerInsights

79

6 Comments

🚀 Just discovered a game-changing way to automate documentation screenshots! As developers and technical writers, we've all been there - spending hours manually creating step-by-step visual guides, taking screenshots, adding highlights, and organizing files. What if I told you there's a way to automate this entire process? ✨ Enter Playwright MCP Server With just one simple prompt, you can: 📸 Automatically navigate websites 🎯 Interact with elements step-by-step 🔴 Add visual CSS borders to highlight actions 💾 Generate organized screenshots instantly The simple prompt: "Navigate to the website and fill in the search term for movie. As you interact with each element, add a red CSS border around the element and take a screenshot." Why this matters:  ⏰ Transforms hours of manual work into minutes 📋 Creates consistent, professional documentation 🔄 Repeatable process for any application 🎓 Perfect for workshops, tutorials, and user guides Who benefits:  👩‍💻 Developers documenting user flows ✍️ Technical writers creating guides 🎯 Product managers showcasing features 🎓 Educators building tutorials The results? Professional-quality visual documentation with zero manual effort. The screenshots are automatically saved with descriptive names, ready to drop into your docs. What automation challenges are you facing in your workflow? Drop a comment below - I'd love to hear about your documentation pain points! #WebDevelopment #Automation #Documentation #Playwright #TechnicalWriting #Productivity #Testing #DevTools https://lnkd.in/dKRbMEvr

375

27 Comments

One of the more controversial things I teach to developers becoming architects is that code quality isn’t as important as architectural quality. In the right architecture, poor code will not bring the system down. In a poor architecture, great code won’t tip the scales. If the industry now insists on poor code at huge volumes, then architecture becomes essential. Because everything is becoming automated and happening at speed, this means old school ”rules of thumb”, artisanal, gut feeling architecture simply won’t scale. We need a scientific approach to architecture. I think the current LLM rush is based on fool’s gold, but if you’re going to insist on doing it because everyone else is, then a scientific approach to architecture is absolutely necessary. https://lnkd.in/dPV4db3A

169

11 Comments

The reason you’re failing at system design rounds is not because you haven’t solved or read those hundreds of case studies and problems out there. It’s because you still don’t have the basics down and you struggle when cross-questioned on fundamentals. Start from here and don’t move forward unless you can explain these topics to a 5 year old. ➥Good resources for building basics: 1// System Design Primer: https://lnkd.in/duPMUhbK 2// Design Patterns for Distributed Systems: https://lnkd.in/g9qsXrNE 3// Must know System Design Concepts: https://lnkd.in/gvPMA-KE ➥ Video Series you can go through: 1// Gaurav Sen - System Design Series - https://lnkd.in/gS_SJnji 2// Tech Dummies - System Design Series -  https://lnkd.in/gSKFpBZZ 3// Hello Interview’s Videos -  https://lnkd.in/gtsq33Hp ➥Free books you can read: 1// Building Microservices  https://lnkd.in/gAj4FkHq 2// Monolith to Microservices https://lnkd.in/gPXX8-xg 3// Distributed Systems  https://lnkd.in/g6zxeHaa

105

12 Comments

🎭 When maintaining larger Playwright codebases, I'm a huge fan of automated quality checks. The smarter the Playwright test runner, the better! One of the scripts I carry over from project to project monitors the network. If a Playwright test "does its thing" and passively encounters any 404s or 500s along the way, I prefer to fail the running test. And ideally, this functionality "just happens" without me worrying about it. With quality checks that monitor network or JavaScript errors in place, you might detect application issues that your tests don't cover. Your tests can't cover every single feature and functionality; however, they might touch multiple non-test-related areas. If some things are broken, a passive quality check might give you an early hint. I consider this a huge win! If this sounds interesting, I just recorded an example showing how you can automatically monitor the network using automatic Playwright fixtures. 👉 https://lnkd.in/eQA3e-52

150

10 Comments

Don't make the mistake of assuming that, because there's no formal code review (e.g., with a Pull Request) that code isn't being reviewed. It might be that code's actually being reviewed *continuously*, and with much more focus and rigour. For example, when I'm doing TDD, after I've passed the newest test and committed the code, I review the code I've added or changed. And I'm quite systematic about - readability, duplication (Rule of Three), complexity, coupling and cohesion, common code smells (long methods, large classes, divergent change, feature envy and so on. Then I run a linter on the changed files - they can do that, dontcha know? - to look for any low-level issues I might have missed; unused imports, fields that could be immutable, methods that could be private, etc etc. And if there are issues, I refactor. And after each refactoring, when my tests are passing, I review the code again in case my refactoring has made the code worse - e.g., harder to understand - and if it has, I might revert/undo and try something else. And you might be thinking, "Gee, that sounds like a lot of work to be doing 10, 20, 30 times an hour!" But here's the thing: we're talking about a few lines of code in each review. And many issues have already been picked up as that code was being written by my pairing partner. Indeed, quite a few issues are caught before the code's even been written by just talking about what we're gonna do next. Because when you've done a gazillion code reviews, and done them systematically, you basically turn into a human linter. So, no, I don't do formal code reviews. But my code *is* reviewed. A LOT.

55

10 Comments

Seems like everyone's talking about database sharding. Earlier this year, I wrote an interactive guide on how it works for relational databases. Every engineer should know the core principles and challenges of sharding. This article is here to help. Read it here: https://lnkd.in/g8gF_sVz

158

14 Comments

If you can’t tab through your product, it’s not accessible. It’s not finished. It’s not “MVP.” It’s a lawsuit waiting to happen. Here’s what most dev teams get wrong: They build with <div>s, <span>s, and CSS. Then they hope screen readers and keyboard users will “figure it out.” Spoiler: they won’t. And they shouldn’t have to. The bar isn’t high, just do this: Use the platform • Use <button>, not a styled <div> • Use <label for="id">, not placeholders • Use <fieldset>, <legend>, <nav>, <main>, <section>, <header>, etc. Fix your tab order • The DOM defines tab order. Visually reordering with CSS is fine but never reorder focus invisibly. • Use tabindex="0" to add focus. • Use tabindex="-1" to manage focus programmatically (e.g. bring focus to a modal). Respect focus • Every interactive element needs a visible focus state (not outline: none) • Modals must trap focus inside • Focus must return where it came from when closed Support real keyboard interaction • Buttons: Enter / Space • Dropdowns: Arrow keys + Enter • Escape: should exit modals, menus, popovers • Don’t invent new interaction models unless you really know what you’re doing TL;DR If you’re not building for keyboard users, you’re not building for the web. You’re building something that fails the moment real users show up. You don’t need to be an accessibility expert. But you do need to stop shipping things you can’t even navigate yourself. Test with a keyboard. Every time. No excuses.

50

3 Comments

Tip: If you need to upgrade your code to a newer version of a package, point GitHub Copilot at the changelog and ask it to make the upgrade. You may also want to note "don't worry about supporting older versions of the package, just use the latest version" as some models like to add excessive exception handling and fallbacks. I'm using this approach to upgrade my Pydantic-AI samples today, and it's working pretty well, since there's a bunch of little fixes across multiple projects.

30

We're going to have a series of talks that get at how times have changed for retrieval systems. Starting with a talk about a testing tool Quepid. Which wouldn't seem to be related. Quepid (http://quepidapp.com) was a labor of love in the early 2010s. Back then much of the search work was hacking at the knobs and dials *within the search engine*. We had tricks for adding managed vocabularies and working with other assets in traditional engines like Solr and Elasticsearch. We would manage Learning to Rank models in the engine itself, and much more But now times have changed, now search is built by wiring together multiple systems. Most people have their search behind an API, which might talk to multiple backend retrieval systems, suitable for different purposes. Now Charlie Hull has evolved Quepid practices to work with, not against, APIs by whipping up a bit of Javascript to work more seamlessly with the site search itself. Hope to see you there Friday. Link in comments!

25

1 Comment

With GitHub’s coding agent, a new pattern has emerged: group PRs. One person kicks it off, but multiple teammates jump in, shaping design together in real time. Reviews are turning into jams, less critique, more creation. It’s not a code review anymore. It’s a code jam, the developer version of FigJam. #github #codingagent #ai

463

35 Comments