Marcus Merrell

During my time at LoopQA, I've found that an effective model for leveraging automation involves a clear division of responsibilities between development and QA teams. I'll caveat this by saying, I generally advocate for developers to refactor the automation they break, but the reality is that most organizations aren't willing to invest their time into it. Hence, having a dedicated QA team for E2E tests often proves more practical. Here's a typical and highly functional workflow: Local Development: -Developers work on their local environments. -They run unit tests and integration tests to ensure their code is functioning as expected. Dev/Test Environment: -Code is merged into a shared Dev/Test environment. -Unit/Integration Tests: These tests must pass before any merge can occur. If they fail, the merge fails. -E2E Sanity Tests: These are also run, but they can fail for both valid and invalid reasons. Developers need to be adept at identifying actual bugs versus new legitimate failures. -Automation teams step in to refactor failing E2E tests to ensure stability. A common problem here is when dev teams opt not to refactor failing tests, leading to false negatives and potential issues down the line. Stage/Pre-Prod Environment: -After passing all tests, the code moves to the Stage/Pre-Prod environment. -Any merge to this environment is contingent on passing E2E tests along with unit and integration tests. Production Environment -Finally, the tested and validated code is merged into the Production environment. Key Insights: -This model ensures that unit/integration tests act as crucial gatekeepers, providing immediate feedback to developers. -E2E tests, maintained by the QA team, ensure overall system validation and highlight integration issues early. -Collaboration and clear division of responsibilities between dev and QA teams maximize the value of automation, leading to robust and reliable code delivery. #SoftwareDevelopment #QA #Testing #DevOps #SoftwareQuality #Automation #ContinuousIntegration #ContinuousDeployment

47

9 Comments

A great reminder here about bugs and "bug reporting pipelines" from Michael Bolton. I highly recommend embracing bugs (threats to value) as a part of your engineering culture. And here is another reminder from the linked blog about what a bug is: "By “bug” I mean something about the product that threatens its value in the opinion of someone who matters. That means the word “bug” is a broad term that encompasses faults, failures, annoyances, and even enhancement opportunities."

5

I’m skeptical about measuring open-source package quality with metrics alone.    •   Low commit/update cadence: Doesn’t indicate low quality. It might signal a stable, well-functioning package that needs minimal maintenance.    •   High number of historical CVEs: Not a sign of low quality. It could show that the package has undergone thorough security scrutiny.    •   Many open issues: Not a reliable indicator. Many issues are more like support tickets, and there are often many duplicates. Quality assessment requires more than just metrics!

3

Great article by Ray Carnes. In my 20+ years in the software industry I've seen companies learn and relearn the basics again and again because each generation of leaders think things are "different this time" because of such and such technology. The frameworks, platforms, underlying technology changes but the principles and foundations are still the same. #softwareengineering

20

3 Comments

Progress = your QA release process growing from 15 minutes to 5 hours. A stat that’s both invigorating & frustrating at the same time. But I think the single best thing you can do to delight your customers is to personally guarantee “it just works”.

10

OK, let's talk about Platform Engineering. Good grief. Platforming is a topic that has grown into a life of its own in tech, and not in a good way. I'm going to row against the current. Platform teams are an anti-pattern. If your developers don't know how to properly provision and maintain infrastructure that is both supportable and minimizes cost and emissions, then you need better developers. Maintaining infrastructure in a consistent, supportable, optimized fashion does not require a team of people. A platform is not infrastructure nor is it the automation to maintain said infrastructure. A platform is a collection of APIs and messages that bind applications together. Again, this does not require a dedicated team of people. Platform teams are waste. Platform engineering is cover for justifying that waste. #platformengineering #platforms

8

13 Comments

I believe that when people lament about tech debt, it's a misdirected complaint. Engineering teams will always be producing some amount of technical "debt." Even if we write beautiful, well-tested code that fits some noble architectural paradigm and meets every standard we can come up with, it is guaranteed to be deficient in some way--either now or to the team's (or our own personal) future views on what constitutes good code. When we write code, we come to some consensus as a team around what approaches we generally accept and what trade-offs we are generally willing to tolerate. And that's completely normal and unavoidable. But when we complain about tech debt, what we are actually complaining about is a deficient process. All software teams need to have dedicated time to revise our work. Far too often, we prioritize feature development over all other things. The end results of that deficient process are, invariably, twofold: a product with shiny new bells and whistles and a sea of spaghetti under the hood; and a team of stressed out engineers who have to work in a messy, frustrating codebase every single day.

19

11 Comments

Good post. I’ll just add that over-engineering and under-engineering are more orthogonal dimensions than the opposites. One can have neither or one or both. Ditto with “best practices”. A third dimension, almost completely divorced from the above two. This, of course, if you’re working on something tangible and nontrivial. If what you need is another “RESTful API” with “AI capabilities”, deployed via Kubernetes and Terraform, monitored with ELK, and developed and maintained by high-churn mid-to-senior engineers, then by all means use all the best practices you are aware of, and don’t forget to get all the agile coaches within reach onboard!

7

3 Comments

I recently facilitated a workshop where a classic "know-it-all" senior developer reluctantly participated. The goal of the day-long Kata Culture Intro workshop was to guide teams in discovering the benefits of TDD and Pairing through a hands-on, Coyote Teaching style collaborative approach. Predictably, this developer voiced common objections throughout the day to TDD, claiming it was unsuitable for complex problems, start-up environments, fast-paced projects, and his personal coding style. My responses aimed to address his misconceptions: Complex problems: I highlighted how TDD excels in these scenarios, actually streamlining the development and discovery process saving valuable time. Start-ups/fast-paced environments: I shared a relevant anecdote from our time at Premera, where we rapidly delivered 13 functional prototypes (these were more than just prototypes) while simultaneously learning Azure. Jim Speaker remember that? Personal coding style: By the end of the day, the developer surprised me by acknowledging, "I had the wrong idea about TDD. Seeing it in action, I realize it could be a huge time-saver for us." While I'm constantly seeking out new methodologies, TDD still remains the most effective tool I've found. When combined with pairing or ensemble programming, its impact on software development is undeniable. TDD is easy to gain awareness of, deceptively challenging to gain proficiency with, and very rewarding/timesaving to have gained fluency with. #TDD #TestDrivenDevelopment #SoftwareDevelopment #Programming #Coding #Agile #ExtremeProgramming #Pairing #EnsembleProgramming

186

50 Comments

Three syllables for you: Lo-co-fy. Worth memorizing as these stand for DEVELOPMENT SPEED 🚀 My colleague, Kamil Stawski, one of Netguru’s frontend engineers, went ahead and tested the Locofy platform for design-to-code conversion. Here’s what he learned: -the code was much cleaner than he expected it to be -tweaks were needed here and there to finetune the UI -BUT the general speed of web development increased [which was the desired output] Now, the tool may not fully automate web engineering yet but it delivers 🙌 With the current pace of acceleration, moving from concepts to tangible results is 🤯

3

"The core art of Operations Management is observing the messy, human chaos of business and applying order to it." The Operator's handbook is a great guide to the various operations disciplines like #businessoperations or #bizops, #revenueoperations or #revops, #financialops or #finops,#legalops, #marketingops, #peopleops and #productoperations / #productops that have emerged as a result of shift from hardware to software-based value creation (see my previous post too --> https://lnkd.in/gwNWwkNh?). Great introduction, though I find it lacking as it did not include factory operations, supply chain, store operations that rely far more on offline-online interfaces. For any operator out there, process, analytics, metrics, cadence, solutioning and execution are the key concepts to apply.

1

2 Comments

Checkout this new test automation coverage overview built specifically for #AI testing bots. (I’m so tried of spreadsheets and grids of red and green squares!). Thoughts or suggestions? If you want to similar reports for your app, just let me know or signup at https://checkie.ai

23

7 Comments

Tired of endless software bugs? Imagine shipping flawless code every time. LambdaTest's Testµ Conference might just be your ticket to QA nirvana. Mark your calendars for August 21-23, 2024. This isn't your average tech meetup. We're talking 60+ influential speakers, 120+ countries represented, and cutting-edge topics like: → Gen AI in testing → Mobile testing mastery → Visual regression tricks → API testing secrets But here's the kicker: You'll rub elbows with QA wizards from Accenture, Wipro, and Datadog. Think of it as a masterclass in modern software testing. Ready to level up your QA game? Head to https://lnkd.in/gtqFtqbw and secure your spot. Your future bug-free self will thank you. What's your biggest QA challenge right now?

1

1 Comment

Wow it’s really hard to figure out how to download Google Chrome Driver, for automating Selenium screen-grabbing. Here’s a guide to how to do it: 1. Go to the download page that has no downloads! https://lnkd.in/e-F92GNm 2. Then navigate to Chrome for Testing: https://lnkd.in/etUDQmRP 3. Search on the page for “chromedriver” 4. Copy (!) the associated link/url for the right OS e.g. https :// storage.googleapis.com / chrome-for-testing-public / 128.0.6591.0 / mac-x64 / chromedriver-mac-x64.zip 5. Paste into the address bar, and download the driver Why why why is this so complicated! Lol Neither Google, nor Gen-AI can currently work out the solution for this. #automation #selenium #chromedriver #tips #tutorial #guide

3 Discovery blindspots from 50 Discos: 1. It's not a real Discovery! 2. Ignoring crucial context 3. Lack of value https://lnkd.in/e3U4tde2 What've you spotted? #discovery #productdiscovery #continuousdiscovery #disco #discoinferno

9

3 Comments

I'm going to post a few challenges I have had as a software QA. I should be relaxing today but those that know me, know my brain is always in thirty places at once. To developers: Trust your QA. Y'all don't know how many times I've heard, "Well, it works on my local". I don't care. In the test environment, it breaks. I do my due diligence to investigate why, present evidence in logs and from the database, present recordings, and meticulously document steps of reproduction and results. And even after, I still get, "It works on my local". Get off the dang local. NO ONE knows this software, app, platform, etc. better than the QA because we live it more than anyone else does. To business analysts: I know you all are overwhelmed. But please stop copying and pasting Acceptance Criteria for similar features. It makes a mess for developers and QA because the AC doesn't match or conflicts with not only the developed feature but integration as well. Which brings me to my next point... What QA is: Everyone thinks of us as just testers. I am sick of that. I spend half my time working with the product owner, BAs, and Devs, just making sure the AC reflects the solution needing to be resolved. I can't tell you how many times I have had to address with the BAs conflicts in a story over AC, nonsensical AC, WTF verbiage, etc. So then the developers get confused and we are in long meetings addressing what is messed up. We are here to help you ask the questions you didn't think to ask. We don't just test..... we look at future issues too. We like process improvements. Automation: Stop asking me to automate a one-off feature test that hasn't even gone through UAT yet. It's time wasted. Too many companies do this. Might as well give me the day off for the time it takes to do that because the automation is useless after UAT. Learn the purpose of automation. Product Owner: When I tell you before a demo not to demo certain things because there are still issues, don't shred me after the demo because you decided to demo them anyway and they break. I TOLD YOU not to do that, and why. Data: QA worst nightmare. My last position I would get two test records to test against 20 AC when I first started. I said "Helz no". I built up a catalog of test records I could use, positive and negative, as I progressed because I want multiple records against every AC. Which I often shared with the developers for their unit tests who loved it. QA needs data, all. You give me two records, don't yell at me that coverage isn't thorough. Probably sounded more a rant. But I'm opinionated. Where many QA are not. And these are common issues. Want to improve QA, improve the above.

54

34 Comments

Waiting for a 30 minute CI pipeline will kill your flow every time. I wrote about how to use Test Impact Analysis to dramatically speed up your test suite! (there's an 8x speedup in the example with FastAPI) Check it out here: https://lnkd.in/dm3a2Gux

28

1 Comment

When dev teams talk about "testing skills", they're usually referring to test *automation* skills - in other words, test programming. These are for sure very useful, but they only address some of the "How" of software testing. What many - let's be honest, most - developers (and, frankly, quite a few testers, too) lack is the "What" of software testing. What tests should we perform? This is where foundations like set theory, logic, finite state machines, combinations and permutations can be darned useful. Most people with a high school or better education are taught this stuff. But how many of us have applied them to software testing (or, if we flip it around TDD-style, software specification)?

39

7 Comments