<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Riccardoshojaei on Medium]]></title>
        <description><![CDATA[Stories by Riccardoshojaei on Medium]]></description>
        <link>https://medium.com/@farzaadshojaei?source=rss-c071efd5a6d9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*C6a4EKnJIvyeNyKFKy2uxQ.jpeg</url>
            <title>Stories by Riccardoshojaei on Medium</title>
            <link>https://medium.com/@farzaadshojaei?source=rss-c071efd5a6d9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:24:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@farzaadshojaei/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Using Machine Learning to Predict Test Failures (A QA Engineer’s Approach)]]></title>
            <link>https://medium.com/@farzaadshojaei/using-machine-learning-to-predict-test-failures-a-qa-engineers-approach-2d5306f635cf?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d5306f635cf</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[qa-engineer]]></category>
            <category><![CDATA[ai-testing]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Sat, 21 Mar 2026 07:36:00 GMT</pubDate>
            <atom:updated>2026-03-21T07:36:00.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IZSbbGz3iMwxlsnd6lhZAg.png" /><figcaption>From logs to intelligent testing with Python and Playwright</figcaption></figure><h3>Introduction</h3><p>As a Software QA Engineer and a Master’s student in Artificial Intelligence, I started noticing something interesting:</p><p>We generate a massive amount of data during testing — logs, response times, system metrics, failure reports — but we rarely <em>learn</em> from it.</p><p>Most QA pipelines still follow a simple rule:</p><blockquote><em>Run all tests → Check pass/fail → Repeat</em></blockquote><p>But what if we could <strong>predict failures before running tests</strong>?</p><p>In this article I want to show how I applied a simple Machine Learning approach to QA — and integrated it into a Playwright-based workflow.</p><h4><strong>The Problem</strong></h4><p>In a typical CI pipeline:</p><ul><li>Hundreds of tests run</li><li>Many are redundant</li><li>Some fail unpredictably (flaky tests)</li><li>Execution time is expensive</li></ul><p>Yet we ignore valuable signals like:</p><ul><li>response time</li><li>CPU usage</li><li>request load</li></ul><p>These are not just metrics — they are <strong>features</strong>.</p><h3>Turning QA Data into a Dataset</h3><p>Let’s reframe testing as a supervised learning problem:</p><ul><li><strong>Features (X)</strong> → system conditions</li><li><strong>Target (y)</strong> → test result (pass/fail)</li></ul><h3>Generating a Larger Dataset</h3><p>For demonstration, we simulate a realistic QA dataset:</p><pre>import pandas as pd<br>import numpy as np<br><br>np.random.seed(420)<br>#Generating a Random Set<br><br>n = 500<br><br>data = pd.DataFrame({<br>    &quot;response_time&quot;: np.random.randint(50, 500, n),<br>    &quot;cpu_usage&quot;: np.random.randint(30, 100, n),<br>    &quot;requests&quot;: np.random.randint(50, 1000, n),<br>})<br><br># create failure pattern<br>data[&quot;failed&quot;] = (<br>    (data[&quot;response_time&quot;] &gt; 300) &amp;<br>    (data[&quot;cpu_usage&quot;] &gt; 80)<br>).astype(int)<br><br># add noise<br>noise = np.random.rand(n) &gt; 0.85<br>data.loc[noise, &quot;failed&quot;] = 1 - data.loc[noise, &quot;failed&quot;]<br><br>print(data.head())</pre><h3>Training a Machine Learning Model</h3><p>We’ll use Logistic Regression to predict failure probability:</p><pre>from sklearn.model_selection import train_test_split<br>from sklearn.linear_model import LogisticRegression<br><br>X = data[[&quot;response_time&quot;, &quot;cpu_usage&quot;, &quot;requests&quot;]]<br>y = data[&quot;failed&quot;]<br><br>X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)<br><br>model = LogisticRegression()<br>model.fit(X_train, y_train)<br><br>accuracy = model.score(X_test, y_test)<br>print(&quot;Model accuracy:&quot;, accuracy)<br></pre><h3>Understanding the Model</h3><p>Let’s inspect feature importance:</p><pre>for feature, coef in zip(X.columns, model.coef_[0]):<br>    print(feature, coef)</pre><p>Example insight:</p><ul><li>response_time → strong impact</li><li>cpu_usage → critical threshold</li><li>requests → secondary factor</li></ul><p>This is exactly what we expect in real systems.</p><h3>Predicting Failures Before Running Tests</h3><p>Now we can predict:</p><pre>sample = [[350, 85, 400]]<br><br>prediction = model.predict(sample)<br>probability = model.predict_proba(sample)<br><br>print(&quot;Prediction:&quot;, prediction)<br>print(&quot;Failure probability:&quot;, probability)</pre><h3>Applying This to QA</h3><p>Instead of blindly running all tests:</p><ul><li>Run <strong>high-risk tests first</strong></li><li>Skip low-risk scenarios</li><li>Focus debugging where it matters</li></ul><h3>Integrating with Playwright</h3><p>Here’s where things get interesting.</p><p>We connect ML predictions to a Playwright test pipeline.</p><h3>Step 1: Save Predictions</h3><pre>data[&quot;failure_prob&quot;] = model.predict_proba(X)[:, 1]<br><br># prioritize tests<br>prioritized = data.sort_values(by=&quot;failure_prob&quot;, ascending=False)<br><br>prioritized.to_csv(&quot;test_priority.csv&quot;, index=False)</pre><h3>Step 2: Playwright Test Runner (TypeScript)</h3><p>We read prioritized tests and execute only high-risk ones:</p><pre>import { test, expect } from &#39;@playwright/test&#39;;<br>import fs from &#39;fs&#39;;<br><br>const data = JSON.parse(<br>  fs.readFileSync(&#39;test_priority.json&#39;, &#39;utf-8&#39;)<br>);<br><br>// threshold for running tests<br>const THRESHOLD = 0.6;<br><br>data<br>  .filter((t: any) =&gt; t.failure_prob &gt; THRESHOLD)<br>  .forEach((t: any, index: number) =&gt; {<br><br>    test(`High-risk test ${index}`, async ({ page }) =&gt; {<br>      await page.goto(&#39;https://example.com&#39;);<br><br>      // simulate scenario<br>      await page.waitForTimeout(t.response_time);<br><br>      const title = await page.title();<br>      expect(title).toBeTruthy();<br>    });<br><br>});</pre><h3>Real-World Extensions</h3><p>You can take this much further:</p><ul><li>Replace Logistic Regression with:</li><li>Random Forest</li><li>XGBoost</li><li>Add features:</li><li>memory usage</li><li>network latency</li><li>API error rates</li><li>Use real logs instead of synthetic data</li></ul><h3>From Automation to Intelligence</h3><p>Traditional QA automation:</p><blockquote><em>Execute → Validate → Repeat</em></blockquote><p>AI-driven QA:</p><blockquote><em>Observe → Learn → Predict → Optimize</em></blockquote><h3>Final Thoughts</h3><p>You don’t need to become a full-time data scientist to use Machine Learning in QA.</p><p>But you do need to shift your mindset:</p><blockquote><em>Stop treating test results as outputs — start treating them as data.</em></blockquote><p>Because once you do…</p><p>Your test framework stops being a script.</p><p>…and starts becoming a <strong>learning system</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d5306f635cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hard Lessons: Mistakes That Transformed My Career as a QA Engineer]]></title>
            <link>https://medium.com/@farzaadshojaei/the-hard-lessons-mistakes-that-transformed-my-career-as-a-qa-engineer-6e3ed8eef824?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e3ed8eef824</guid>
            <category><![CDATA[softskillsimprovement]]></category>
            <category><![CDATA[qa-engineer]]></category>
            <category><![CDATA[software-tester]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Thu, 11 Dec 2025 08:41:28 GMT</pubDate>
            <atom:updated>2025-12-11T08:41:28.744Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*56PI3Hgi5VRiroGypVOhkQ.png" /></figure><p>No one starts their career knowing exactly what they’re doing. We learn by trying, failing, adjusting, and trying again. Looking back at my own journey in QA engineering over the past 3 years, I’ve realized that the biggest leaps in my growth came not from successes, but from mistakes — the quiet lessons hidden inside uncomfortable moments.</p><p>Some of these mistakes were technical. Others were about communication, timing, or simply not understanding how people work. But each one pushed me to rethink how I approach quality, collaboration, and my role within a team.</p><p>Today, I can see how those missteps shaped the engineer I’ve become. They taught me to slow down, ask better questions, build stronger relationships, and think beyond the bug tracker.</p><h3>1. Not Understanding the Personality Type of a Developer</h3><p>Early in my career, I assumed all developers thought, communicated, and worked the same way.I didn’t realize how much <em>personality</em> affects collaboration.I still remember one day when I needed to visit a developer in person to reproduce a bug. I didn’t know he had ADHD, and my unexpected interruption completely derailed his focus for the rest of the day.</p><p>That experience taught me something important: not everyone works well with face-to-face interruptions. Some developers prefer asynchronous communication — a simple message, a written explanation, or a link to logs — rather than being pulled out of their concentration zone.</p><p>It was a turning point for me. I learned to adapt my approach to each developer, communicate more respectfully, and consider how my actions might impact someone else’s productivity.</p><p>Some developers prefer direct, concise messages. Others need detailed context. Some are defensive about bugs; others welcome them. I treated everyone the same — and that created unnecessary friction.</p><p>Understanding personality types (introvert vs. extrovert, analytical vs. fast-paced, perfectionist vs. pragmatic) helps you tailor communication. It improves empathy, reduces conflict, and leads to smoother collaboration.</p><p><strong>What I learned:</strong><br> Your job as a QA is not just to find bugs — it’s to build relationships. The way you report a bug matters just as much as the bug itself.</p><h3>2. Not Understanding the Software Testing Life Cycle — or Not Producing One When It Didn’t Exist</h3><p>I joined teams where there was no clear STLC. Instead of stepping up and defining the process, I tried to work within the chaos. That was a mistake.</p><p>Without a structured STLC:</p><ul><li>QA becomes reactive instead of proactive</li><li>Test coverage becomes unpredictable</li><li>Release cycles get unstable</li><li>Trust between teams weakens</li></ul><p>I should have introduced basic elements: requirement analysis, planning, test design, execution, reporting, and closure. Even a simple documented flow can transform a team.</p><p>I tried to operate inside the chaos. This slowed down the entire QA process and created inconsistent test coverage.</p><p>Eventually, I realized that if the testing process isn’t defined, it’s my responsibility to build it. I needed to create the STLC from the ground up: requirement analysis, planning, test design, execution, reporting, and closure.</p><p>Defining a process gave the team structure, increased transparency, and created a shared understanding of how quality should be measured and delivered.</p><p><strong>What I learned:</strong><br> If a process doesn’t exist, <em>create it</em>. If it exists but is broken, <em>fix it</em>. QA is not just testing — it is quality engineering.</p><h3>3. Developing Automated Tests Before Fully Understanding the Test Scenarios</h3><p>I once believed automation = efficiency. So I automated early, before fully exploring the functional flows, edge cases, and failure points.</p><p>The result?</p><ul><li>Automated tests didn’t match real-world user flows</li><li>They failed for the wrong reasons</li><li>They missed critical bugs</li><li>They created maintenance overhead instead of value</li></ul><p>Automation only works when the logic behind it is crystal clear. Good automation is not about writing code — it’s about understanding the product deeply.</p><p>As I gained experience, I learned that automation isn’t just about writing code. It’s about writing <strong>the right tests</strong>, in <strong>the right environment</strong>, at <strong>the right time</strong>. Automated tests must run in a <strong>development or staging environment</strong>, and they should be integrated into <strong>CI/CD pipelines</strong> to create continuous value.</p><p><strong>What I learned:</strong><br> Automation should never lead the testing process; it should <em>follow</em> a strong understanding of test scenarios.</p><h3>4. Not Implementing Shift-Left Testing in the Early Stages</h3><p>I waited too long to get involved. I waited for Figma designs, for API documentation, for builds, for something “final.”</p><p>But shift-left testing means being involved much earlier:</p><ul><li>Adding questions and feedback during requirement definition</li><li>Identifying missing acceptance criteria</li><li>Adding risk analysis before development starts</li><li>Helping PMs and developers foresee pitfalls</li></ul><p>When QA enters the conversation early, development becomes smoother, bugs become cheaper to fix, and misunderstandings disappear before they cause damage.</p><p>Shift-left testing isn’t a buzzword — it’s a mindset that saves teams time, energy, and frustration.</p><p><strong>What I learned:</strong><br> Quality does not start at testing — it starts at the first conversation.</p><h3>5. Not Building Strong Relationships With Design, Customer Success, and Other Non-Engineering Teams</h3><p>Early on, I only collaborated with developers. I didn’t understand how much value other teams could provide.</p><p>Design teams help you catch UX inconsistencies before development.<br> Customer success teams show you real user frustrations and hidden pain points.<br> Marketing and product teams help you understand the business impact of bugs.</p><p>By not building these connections, I missed context, misunderstood user priorities, and sometimes tested the wrong things.</p><p><strong>What I learned:</strong><br> QA is the intersection of tech, design, and user experience.<br> If you isolate yourself in engineering, you limit your impact.</p><p>This article is not about regret — it’s about reflection. It’s about the lessons I wish I had understood earlier, and the hope that sharing them might help someone else grow a little faster, with a little less friction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e3ed8eef824" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Recording to Prompting: How Cypress Transforms Test Automation]]></title>
            <link>https://medium.com/@farzaadshojaei/from-recording-to-prompting-how-cypress-transforms-test-automation-ada5fd874247?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/ada5fd874247</guid>
            <category><![CDATA[cypress]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[ai-autonomous-agents]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Fri, 07 Nov 2025 10:39:36 GMT</pubDate>
            <atom:updated>2025-11-08T14:16:10.542Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XQvltpMWPcbT4l4W1TjOLA.png" /></figure><p>Modern test automation is evolving rapidly. Writing Cypress tests from scratch can be time-consuming, especially for teams that are still getting comfortable with JavaScript and the Mocha framework. Fortunately, Cypress now offers two complementary tools that make test creation faster and smarter: <strong>Cypress Studio</strong> and <strong>Cy.Prompt() command</strong>.</p><p>Together, they enable you to move from visual recording to AI-generated test scripts with minimal effort. This article explains what each tool does and shows how to use them in practice.</p><h3>What Is Cypress Studio?</h3><p><strong>Cypress Studio</strong> is a visual recorder built directly into Cypress. Instead of manually typing every cy.get() and cy.click() command, you can perform actions inside the browser while Studio automatically generates the corresponding test code.</p><p>This feature simplifies test creation for beginners and speeds up repetitive scripting for experienced testers. It supports most common actions — clicking buttons, typing text, selecting dropdown items, and checking boxes — while providing a live preview of each step.</p><p><strong>Key benefits include:</strong></p><ul><li><strong>Lower learning curve:</strong> Perfect for teams new to Cypress or JavaScript.</li><li><strong>Rapid test creation:</strong> Record UI interactions instead of writing commands.</li><li><strong>Code reuse:</strong> Recorded scripts can be saved, edited, and expanded.</li><li><strong>Visual debugging:</strong> Observe the state of the application at each step.</li><li><strong>Visual validation:</strong> Verify that UI elements appear correctly.</li></ul><p>To enable Cypress Studio, add the following line to your configuration file:</p><pre>// cypress.config.js<br>module.exports = {<br>  e2e: {<br>    experimentalStudio: true,<br>  },<br>};</pre><p>Then start cypress with</p><pre>npx cypress open</pre><h3>Creating a Simple Test with Cypress Studio</h3><p>Let’s create a basic login test to see how Cypress Studio works.</p><p><strong>Step 1 — Create the test file</strong></p><p>Inside the e2e folder, create a file named cypressStudio.cy.js:</p><pre>describe(&#39;Cypress Studio Demo&#39;, () =&gt; {});</pre><p><strong>Step 2 — Record the steps</strong></p><p>Open the Cypress Runner and select “Create test with Cypress Studio.”</p><ol><li>Enter the target URL: <a href="https://www.saucedemo.com/">https://www.saucedemo.com/.</a></li><li>Click <strong>Continue</strong> to launch Studio.</li><li>Interact with the page as a user would: type the username, type the password, and click <strong>Login</strong>.</li></ol><p>Cypress automatically records each interaction and generates executable code:</p><pre>describe(&#39;Cypress Studio Demo&#39;, () =&gt; {<br>  it(&#39;CypressStudio&#39;, function() {<br>    cy.visit(&#39;https://www.saucedemo.com/&#39;);<br>    cy.get(&#39;[data-test=&quot;username&quot;]&#39;).clear(&#39;standard_user&#39;);<br>    cy.get(&#39;[data-test=&quot;username&quot;]&#39;).type(&#39;standard_user&#39;);<br>    cy.get(&#39;[data-test=&quot;password&quot;]&#39;).clear(&#39;secret_sauce&#39;);<br>    cy.get(&#39;[data-test=&quot;password&quot;]&#39;).type(&#39;secret_sauce&#39;);<br>    cy.get(&#39;[data-test=&quot;login-button&quot;]&#39;).click();<br>  });<br>});j</pre><p>The result is a complete, working login test — created entirely through the browser without writing code manually.</p><h3>What Is cy.prompt()?</h3><p><strong>cy.prompt()</strong> is an experimental AI-powered command that converts natural-language instructions into Cypress test code.<br> Where Studio records user actions, cy.prompt() <em>interprets text prompts</em> and generates equivalent Cypress commands automatically.</p><p>You can use it in two ways:</p><ul><li>To <strong>generate new tests</strong> from simple English steps.</li><li>To <strong>continuously self-heal</strong> existing tests as your application evolves.</li></ul><p>Example</p><pre>cy.prompt(<br>  [<br>    &#39;visit https://cloud.cypress.io/login&#39;,<br>    &#39;type &quot;user@example.com&quot; in the email field&#39;,<br>    &#39;type {{password}} in the password field&#39;,<br>    &#39;click the login button&#39;,<br>    &#39;verify we are redirected to the dashboard&#39;,<br>  ],<br>  {<br>    placeholders: { password: &#39;secret123&#39; },<br>  }<br>);</pre><p>Each line is converted into Cypress commands that visit the page, fill in fields, click the button, and verify navigation — no selectors or syntax required.</p><h3>Writing Effective Prompts</h3><p>Clarity determines accuracy. Follow these guidelines to get consistent results:</p><ul><li>Use the <strong>imperative voice</strong>: start with an action verb such as <em>click</em>, <em>type</em>, or <em>verify</em>.</li><li>Use <strong>absolute URLs</strong> (for example, <a href="https://app.example.com)./">https://app.example.com).</a></li><li>Keep <strong>one action per line</strong>.</li><li>Be explicit: wrap exact text or values in quotes.</li><li>Include <strong>context</strong> when describing an element, such as <em>click the “Login” button in the header</em>.</li></ul><p>Good prompt:</p><blockquote><em>click the “Submit” button on the registration form</em></blockquote><p>Bad prompt:</p><blockquote><em>click submit button</em></blockquote><p>cy.prompt() currently performs best with English instructions; other languages are not fully supported.</p><h3>Rewriting the Cypress Studio Test with Cypress Prompt</h3><p>Now let’s rewrite the earlier login test using only cy.prompt().</p><pre>describe(&#39;Cypress Prompt Demo&#39;, () =&gt; {<br>  it(&#39;Logs in using natural language&#39;, () =&gt; {<br>    cy.prompt(<br>      [<br>        &#39;visit https://www.saucedemo.com/&#39;,<br>        &#39;type &quot;standard_user&quot; in the username field&#39;,<br>        &#39;type &quot;secret_sauce&quot; in the password field&#39;,<br>        &#39;click the login button&#39;,<br>        &#39;verify that the products page is displayed&#39;,<br>      ]<br>    );<br>  });<br>});</pre><p>This short prompt produces equivalent behavior to the longer Cypress Studio script:</p><pre>cy.visit(&#39;https://www.saucedemo.com/&#39;);<br>cy.get(&#39;[data-test=&quot;username&quot;]&#39;).type(&#39;standard_user&#39;);<br>cy.get(&#39;[data-test=&quot;password&quot;]&#39;).type(&#39;secret_sauce&#39;);<br>cy.get(&#39;[data-test=&quot;login-button&quot;]&#39;).click();<br>cy.contains(&#39;Products&#39;).should(&#39;be.visible&#39;);</pre><p>The two tests perform the same steps — one was recorded visually, and the other was generated entirely from plain English.</p><h3>Conclusion</h3><p>Cypress Studio and Cypress Prompt mark a significant shift in how automated tests are created and maintained.<br> With <strong>Cypress Studio</strong>, anyone can record realistic test scenarios directly in the browser. With <strong>Cy.prompt()</strong>, those same scenarios can be written or refined through simple, human-readable instructions.</p><p>Used together, they form a complete workflow — from recording to prompting to refinement — that reduces setup time, lowers the learning barrier, and introduces AI-assisted adaptability to Cypress testing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ada5fd874247" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Bug Reports: Soft Skills Every QA Engineer Needs : Part 1]]></title>
            <link>https://medium.com/@farzaadshojaei/beyond-bug-reports-soft-skills-every-qa-engineer-needs-a34ee668f655?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/a34ee668f655</guid>
            <category><![CDATA[qa-engineering]]></category>
            <category><![CDATA[soft-skills]]></category>
            <category><![CDATA[quality-engineering]]></category>
            <category><![CDATA[softskillsimprovement]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Fri, 03 Oct 2025 17:21:15 GMT</pubDate>
            <atom:updated>2025-10-04T06:00:23.499Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7j4qY9NYxlcPUh8o6gr3bw.jpeg" /></figure><p>When most people think about QA engineers, they imagine someone running test cases and filing bug reports. But the truth is: QA is not just about finding bugs — it’s about <strong>communicating problems clearly, collaborating with different stakeholders, and helping the team make better decisions.</strong></p><p>In my own experience, the hardest part of QA isn’t spotting defects — it’s making sure those defects are understood and acted upon without friction. And that’s where <strong>soft skills</strong> make all the difference.</p><p>Let’s look at a few key skills that help QA engineers work smoothly with developers and product managers, backed with real-world examples.</p><h3>1. Communication: From “Bug Reports” to “Bug Stories”</h3><p>Good QA engineers don’t just log bugs; they <strong>tell the story of the bug</strong>.<br> Imagine two versions of the same report:</p><p>❌ <em>“Login button doesn’t work.”</em><br> ✔️ <em>“On Chrome 134, clicking the login button doesn’t trigger any API request. The console shows a </em><em>TypeError. This blocks users from signing in, preventing them from accessing the dashboard.”</em></p><p>The second version not only explains the issue but also gives context on <strong>why it matters</strong>. Developers appreciate the reproducible steps, while product managers see the user impact.</p><p>A useful trick: Before hitting “Submit” on a bug, ask yourself — would someone with zero context understand this?</p><h3>2. Empathy: Seeing Through Their Eyes</h3><p>It’s tempting to think of QA as being “against” developers and PMs — after all, you’re the one pointing out flaws. But empathy changes everything.</p><ul><li><strong>For developers</strong>: Think about their pressure to deliver features quickly. Instead of saying, <em>“You missed this bug,”</em> try <em>“I think this edge case might have slipped through; here’s how I found it.”</em></li><li><strong>For product managers</strong>: They care less about stack traces and more about business outcomes. Instead of <em>“Dropdown is broken,”</em> try <em>“Users can’t select a payment method, which means purchases can’t go through.”</em></li></ul><p>By framing issues in terms that matter to your audience, you avoid conflict and build trust.</p><h3>3. Critical Thinking: Beyond the Symptom</h3><p>Anyone can say “this doesn’t work,” but great QA engineers go further: they <strong>explore possible causes and patterns</strong>.</p><p>For example:</p><ul><li>Instead of reporting “file upload fails,” you might notice it only happens with files larger than 10MB.</li><li>Instead of logging “checkout crashes,” you dig and find it occurs only when a discount code is applied.</li></ul><p>This detective work saves developers hours of debugging. It also makes you look less like a “bug finder” and more like a <strong>problem solver</strong>.</p><h3>4. Negotiation: Balancing Quality and Deadlines</h3><p>Sometimes, a product manager wants to push a feature live even though you’ve flagged a bug. Developers may insist it’s “not critical.”</p><p>Here’s where <strong>negotiation</strong> comes in:</p><ul><li>Don’t frame it as <em>“this must be fixed.”</em></li><li>Frame it as <em>“Here’s the risk if we ship this now: 20% of mobile users won’t be able to complete checkout. Do we accept that risk, or should we delay?”</em></li></ul><p>By presenting issues as <strong>risk trade-offs</strong>, you shift the discussion from confrontation to collaboration. It becomes a business decision, not a personal argument.</p><h3>5. Proactive Collaboration: QA Beyond Testing</h3><p>The best QA engineers don’t wait until features are “ready for testing.” They join early — in grooming sessions, design reviews, and planning calls.</p><p>Example: If you see a story about uploading images but no mention of file size limits, you can ask: <em>“Do we want to restrict uploads to 10MB?”</em> That question saves everyone headaches later.</p><p>Proactivity signals that you’re not just testing the product — you’re <strong>helping shape it.</strong></p><h3>Final Thoughts: Quality Is a Team Sport</h3><p>At the end of the day, QA isn’t just about raising bugs. It’s about <strong>building trust</strong> across the team and ensuring that quality becomes a shared responsibility.</p><p>Next time you log a defect, try this:</p><ul><li>Tell the story, not just the symptom.</li><li>Show empathy for both the developer and the PM.</li><li>Think critically and explore root causes.</li><li>Negotiate by highlighting risks, not personal opinions.</li><li>And most importantly, collaborate early instead of acting as the “last line of defense.”</li></ul><p>Because in modern software development, the best QA engineers aren’t just testers — they’re <strong>communicators, diplomats, and problem-solvers.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a34ee668f655" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a SQA is responsible for writing a secure code?]]></title>
            <link>https://medium.com/@farzaadshojaei/how-a-sqa-is-responsible-for-writing-a-secure-code-1eb0dfb79599?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1eb0dfb79599</guid>
            <category><![CDATA[playwright-test]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[security-testing]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Thu, 31 Jul 2025 10:40:30 GMT</pubDate>
            <atom:updated>2025-07-31T10:40:30.677Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BmG-NO7n5X8Er_dXeXL-mQ.png" /></figure><p>As a QA Engineer, you may focus on reliability, performance, and test coverage — but there’s an increasingly critical area we must own: <strong>security</strong>.</p><p>With repositories often public or accessible by contractors, <strong>test code can be a prime target for bug bounty hunters and also security engineer may need to double-check your code which is time consuming.</strong> QA Engineers are part of the secure software lifecycle, and writing secure automation code is no longer optional.</p><h3>Why Secure Test Code Matters</h3><p>Even though automation scripts don’t run in production, they usually interact with:</p><ul><li>Real or staging environments</li><li>Login flows and access tokens</li><li>Internal APIs, dashboards, and analytics</li><li>Logs that could leak tokens, emails, or session IDs</li></ul><p>Test code <strong>should be treated as production-grade</strong>, especially in CI/CD pipelines or shared repositories.</p><h3>What Should Never Be in Your Test Code</h3><h4>1. Hardcoded Credentials</h4><pre>await page.getByTestId(&#39;login-username&#39;).fill(&#39;admin@example.com&#39;);<br>await page.getByTestId(&#39;login-password&#39;).fill(&#39;SuperSecret123!&#39;);t</pre><p>Use <strong>process.env</strong> :</p><pre>await page.getByTestId(&#39;login-username&#39;).fill(process.env.LOGIN_USER || &#39;&#39;);<br>await page.getByTestId(&#39;login-password&#39;).fill(process.env.LOGIN_PASS || &#39;&#39;);</pre><h4>2. API Keys and Tokens</h4><pre>headers: {<br>  Authorization: &#39;Bearer sk_test_abc123&#39;,<br>}</pre><p>Store in .env, access with:</p><pre>Authorization: `Bearer ${process.env.API_TOKEN}`</pre><h4>3. Internal Environment URLs</h4><pre>page.goto(&#39;https://staging.internal.company.local/dashboard&#39;);</pre><p>Instead:</p><pre>page.goto(`${process.env.TEST_BASE_URL}/dashboard`);</pre><h4>4. Session Snapshots and Auth Files</h4><p>Playwright can save your session as .auth.json — <strong>which contains cookies and tokens.</strong></p><p>Always add to .gitignore:</p><pre>test/.auth.json</pre><h3>How to Properly Hide .env Files:</h3><h4>1. Add .env to .gitignore</h4><pre>.env<br>.env.local<br>.env.test<br>test/.auth.json</pre><h4>2. Use .env.example to share structure:</h4><pre>LOGIN_USER=<br>LOGIN_PASS=<br>API_TOKEN=<br>TEST_BASE_URL=</pre><h3>How Secret Detection Tools Work</h3><h3>GitLeaks</h3><ul><li>Scans repo and commit history using regex + entropy</li><li>Detects common secret patterns like API keys and passwords</li></ul><pre>gitleaks detect --source .</pre><h3>TruffleHog</h3><ul><li>Scans both current and historical commits</li><li>Detects secrets using known patterns and entropy models</li></ul><pre>trufflehog git file://.</pre><h3>GitHub Secret Scanning</h3><ul><li>Available for public and private repos</li><li>Alerts you when secrets are pushed to your repository</li></ul><p>Enable under:<br> <strong>Repo → Settings → Security → Secret scanning</strong></p><h3>Useful Tips for QA Engineers</h3><h4>Tip 1: Use CI/CD Secrets Management</h4><p>Never pass credentials as plain text in GitHub Actions or GitLab CI. Use:</p><pre>env:<br>  LOGIN_USER: ${{ secrets.LOGIN_USER }}</pre><h4>Tip 2: Create Role-Based Test Accounts</h4><p>Don’t test with real admin accounts. Use dedicated test users with scoped permissions.</p><h4>Tip 3: Sanitize Your Logs</h4><p>Avoid logging sensitive values:</p><pre>console.log(`Logging in as ${email}`); // ok<br>console.log(`Password is ${password}`); // ❌ avoid this</pre><h4>Tip 4: Review Git History for Leaks</h4><p>Use:</p><pre>git log -p | grep -i &#39;password\|token\|secret&#39;</pre><p>This helps find previous secrets accidentally committed.</p><h4>Tip 5: Use dotenv-safe for secure startup</h4><p>Ensure your .env files are complete and valid:</p><pre>npm install dotenv-safe</pre><p>Then in your playwright.config.ts or entrypoint:</p><pre>require(&#39;dotenv-safe&#39;).config();</pre><h3>What Bug Bounty Hunters Search For:</h3><ul><li>.env, .auth.json, and credentials in open repos</li><li>Committed tokens or Authorization headers</li><li>Internal URLs that expose staging/admin tools</li><li>Hardcoded test accounts or password reset endpoints</li></ul><h3>Final Takeaway</h3><blockquote><strong><em>Security is not just for developers.</em></strong><em><br> As QA engineers, we must treat test code like production.</em></blockquote><p>Every test suite, every log, and every config file can be a target. Let’s build tests that are <strong>not only reliable, but secure by design.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1eb0dfb79599" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Traditional Testing to Blockchain QA: The Complete Professional Guide — Part 2]]></title>
            <link>https://medium.com/@farzaadshojaei/from-traditional-testing-to-blockchain-qa-the-complete-professional-guide-part-2-62d242e9ae96?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/62d242e9ae96</guid>
            <category><![CDATA[blockchain-testing]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[blockchain-development]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Fri, 04 Jul 2025 07:53:12 GMT</pubDate>
            <atom:updated>2025-07-04T07:53:12.402Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Traditional Testing to Blockchain QA: The Complete Professional Guide — Part 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*KfGfYyrMn5vrwkBMFtjDHA.jpeg" /></figure><h3>Blockchain Interaction and Monitoring Tools</h3><p><strong>Web3.js and Ethers.js</strong> are essential JavaScript libraries:</p><ul><li><strong>Web3.js</strong>: Comprehensive library for Ethereum interaction</li><li><strong>Ethers.js</strong>: More modular, TypeScript-friendly alternative</li><li>Both provide wallet management, contract interaction, and event monitoring</li></ul><p><strong>MetaMask</strong> serves as the primary wallet for testing:</p><ul><li>Browser extension for easy DApp testing</li><li>Custom network configuration for testnets</li><li>Transaction history and debugging information</li><li>Developer mode for advanced testing scenarios</li></ul><p><strong>Ganache</strong> provides local blockchain simulation:</p><ul><li>Personal Ethereum blockchain for development</li><li>Account management with pre-funded addresses</li><li>Transaction and block inspection</li><li>Forking capabilities for mainnet testing</li></ul><p><strong>Remix IDE</strong> offers browser-based smart contract development:</p><ul><li>No setup required — runs entirely in browser</li><li>Integrated compiler and debugger</li><li>Multiple plugin support</li><li>Excellent for prototyping and education</li></ul><h3>API Testing and Integration Tools</h3><p><strong>Postman</strong> remains crucial for API testing:</p><ul><li>GraphQL and REST API testing</li><li>Environment management for different networks</li><li>Automated test collection execution</li><li>Team collaboration features</li></ul><p><strong>Insomnia</strong> provides an alternative API testing environment:</p><ul><li>Clean, intuitive interface</li><li>GraphQL query builder</li><li>Plugin ecosystem</li><li>Environment and workspace management</li></ul><p><strong>Newman</strong> enables command-line API testing:</p><ul><li>Postman collection runner for CI/CD</li><li>Automated test execution</li><li>Detailed reporting capabilities</li><li>Integration with testing pipelines</li></ul><h3>Network and Infrastructure Testing Tools</h3><p><strong>Tenderly</strong> offers advanced blockchain monitoring and debugging:</p><ul><li>Transaction simulation and debugging</li><li>Smart contract monitoring and alerting</li><li>Gas profiling and optimization suggestions</li><li>Incident response and root cause analysis</li></ul><p><strong>Etherscan and Block Explorers</strong> provide essential verification capabilities:</p><ul><li>Transaction verification and tracing</li><li>Contract source code verification</li><li>Event log analysis</li><li>Network statistics and health monitoring</li></ul><p><strong>Infura and Alchemy</strong> serve as reliable node providers:</p><ul><li>Production-grade Ethereum and IPFS APIs</li><li>Analytics and monitoring dashboards</li><li>Rate limiting and usage tracking</li><li>Multiple network support</li></ul><h3>Load Testing and Performance Tools</h3><p><strong>Artillery</strong> provides load testing for APIs:</p><ul><li>High-performance load testing</li><li>Complex scenario definition</li><li>Real-time monitoring</li><li>Integration with CI/CD pipelines</li></ul><p><strong>JMeter</strong> offers comprehensive performance testing:</p><ul><li>GUI and command-line interfaces</li><li>Distributed testing capabilities</li><li>Extensive reporting features</li><li>Plugin ecosystem for blockchain-specific testing</li></ul><h3>Multi-Chain and Cross-Chain Testing Tools</h3><p><strong>Moralis</strong> simplifies multi-chain development:</p><ul><li>Cross-chain APIs for multiple blockchains</li><li>Real-time data synchronization</li><li>Authentication and user management</li><li>NFT and DeFi-specific endpoints</li></ul><p><strong>ChainSafe</strong> provides bridging and cross-chain tools:</p><ul><li>Cross-chain bridge testing frameworks</li><li>Multi-chain deployment tools</li><li>Interoperability testing capabilities</li><li>Protocol-agnostic development tools</li></ul><h3>Automated Testing and CI/CD Integration</h3><p><strong>GitHub Actions</strong> enables automated testing workflows:</p><ul><li>Trigger tests on code commits</li><li>Matrix testing across multiple environments</li><li>Integration with deployment pipelines</li><li>Cost-effective for open-source projects</li></ul><p><strong>Jenkins</strong> provides enterprise-grade automation:</p><ul><li>Complex pipeline management</li><li>Plugin ecosystem for blockchain tools</li><li>Distributed testing capabilities</li><li>Enterprise security and compliance features</li></ul><p><strong>Docker</strong> containerizes testing environments:</p><ul><li>Consistent testing environments across teams</li><li>Easy integration with CI/CD systems</li><li>Resource isolation and management</li><li>Simplified deployment processes</li></ul><h3>Essential Browser Extensions and Development Tools</h3><p><strong>MetaMask Developer Tools</strong> enhance wallet testing:</p><ul><li>Custom network configuration</li><li>Transaction debugging</li><li>Account switching and management</li><li>DApp permission management</li></ul><p><strong>Wallet Connect</strong> enables multi-wallet testing:</p><ul><li>QR code-based wallet connections</li><li>Support for 100+ wallets</li><li>Cross-platform compatibility</li><li>Session management and security</li></ul><h3>Data Analysis and Monitoring Tools</h3><p><strong>Dune Analytics</strong> provides blockchain data analysis:</p><ul><li>SQL-based query interface</li><li>Pre-built dashboard templates</li><li>Community-shared queries and insights</li><li>Custom visualization capabilities</li></ul><p><strong>The Graph</strong> enables decentralized data indexing:</p><ul><li>GraphQL APIs for blockchain data</li><li>Custom subgraph development</li><li>Real-time data synchronization</li><li>Decentralized query processing</li></ul><h3>Tool Selection Strategy</h3><p><strong>For Beginners:</strong> Start with Remix IDE for smart contract learning, MetaMask for wallet interaction, and Hardhat for development framework.</p><p><strong>For Security Focus:</strong> Master Slither for static analysis, Echidna for fuzzing, and MythX for comprehensive security testing.</p><p><strong>For DeFi Testing:</strong> Use Foundry for advanced testing, Tenderly for transaction debugging, and Dune Analytics for data analysis.</p><p><strong>For Enterprise:</strong> Implement Jenkins for CI/CD, Docker for containerization, and comprehensive monitoring with Tenderly and custom alerting systems.</p><p>The key to success is not mastering every tool immediately, but understanding which tools solve which problems and building expertise progressively based on your project needs and career focus.</p><h3>Common Challenges and How to Overcome Them</h3><h3>Technical Complexity</h3><p>Blockchain technology can be overwhelming initially. Start with fundamentals and build complexity gradually. Don’t try to learn everything at once — focus on one blockchain ecosystem first, then expand.</p><h3>Keeping Up with Rapid Changes</h3><p>The pace of innovation can be exhausting. Focus on core principles that remain constant while staying aware of major developments. Set aside time weekly for learning and experimentation.</p><h3>Security Mindset</h3><p>Blockchain QA requires a security-first mindset that’s different from traditional testing. Start with basic security concepts and gradually build expertise through practice and study.</p><h3>Market Volatility</h3><p>The blockchain industry experiences significant ups and downs. Build diverse skills that transfer across different sectors and maintain financial stability during transitions.</p><h3>The Future of Blockchain QA</h3><p>As blockchain technology matures, several trends will shape the future of blockchain QA:</p><p><strong>Increased Regulation:</strong> Government oversight will create demand for compliance testing specialists who understand both blockchain technology and regulatory requirements.</p><p><strong>Enterprise Adoption:</strong> Large corporations adopting blockchain will need QA professionals who can bridge traditional enterprise practices with blockchain innovation.</p><p><strong>Cross-Chain Interoperability:</strong> The future is multi-chain, creating opportunities for specialists in cross-chain testing and protocol compatibility.</p><p><strong>AI-Powered Testing:</strong> Machine learning will augment blockchain testing, creating opportunities for QA engineers who understand both domains.</p><p>The question isn’t whether blockchain will transform industries — it’s whether you’ll be part of that transformation. Your journey into blockchain QA starts now.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62d242e9ae96" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Traditional Testing to Blockchain QA: The Complete Professional Guide — Part 1]]></title>
            <link>https://medium.com/@farzaadshojaei/from-traditional-testing-to-blockchain-qa-the-complete-professional-guide-part-1-fff53ce857cc?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fff53ce857cc</guid>
            <category><![CDATA[blockchain-development]]></category>
            <category><![CDATA[blockchain-technology]]></category>
            <category><![CDATA[test-engineer]]></category>
            <category><![CDATA[qa-engineer]]></category>
            <category><![CDATA[qa-testing]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Fri, 30 May 2025 06:40:08 GMT</pubDate>
            <atom:updated>2025-05-30T06:40:08.177Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Traditional Testing to Blockchain QA: The Complete Professional Guide — Part 1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*phaANP9NZDYaWrO_pGlxZA.png" /></figure><p>The blockchain industry is experiencing unprecedented growth, with global blockchain market size expected to reach $1.4 trillion by 2030. As this revolutionary technology matures, there’s an increasing demand for skilled quality assurance professionals who can ensure the reliability, security, and performance of blockchain applications. If you’re a QA engineer looking to pivot into this cutting-edge field, or someone entirely new to testing who wants to specialize in blockchain from the start, this comprehensive guide will show you exactly how to make that transition.</p><h3>Why Blockchain QA is Different (and Why It Matters)</h3><p>Traditional software testing focuses on centralized applications where you control the entire stack. Blockchain QA introduces unique challenges that make it both more complex and more rewarding:</p><p><strong>Immutability:</strong> Once deployed to mainnet, smart contracts cannot be easily changed. A single bug can result in millions of dollars in losses, making thorough testing absolutely critical.</p><p><strong>Decentralization:</strong> Applications run across multiple nodes, creating new failure modes and testing scenarios that don’t exist in traditional systems.</p><p><strong>Financial Stakes:</strong> Most blockchain applications handle real money. The financial implications of bugs are immediate and often irreversible.</p><p><strong>Regulatory Compliance:</strong> As governments worldwide implement blockchain regulations, compliance testing becomes increasingly important.</p><p>These factors create a high-demand, high-value specialization where skilled blockchain QA engineers can command premium salaries while working on technology that’s reshaping the global financial system.</p><h3>What Does a Blockchain QA Engineer Actually Do?</h3><p>Before diving into the landscape, let’s understand the day-to-day reality of blockchain QA work:</p><p><strong>Smart Contract Testing:</strong> You’ll spend significant time reviewing and testing smart contract code before deployment. This involves writing unit tests, integration tests, and security tests to ensure contracts behave correctly under all conditions. A single overlooked edge case could result in millions of dollars in losses.</p><p><strong>DApp End-to-End Testing:</strong> Testing decentralized applications requires validating the entire user journey from wallet connection to transaction completion. You’ll test across different browsers, wallet providers, and network conditions to ensure consistent user experience.</p><p><strong>Security Vulnerability Assessment:</strong> Blockchain QA engineers actively hunt for security flaws using automated tools and manual review. You’ll look for common vulnerabilities like reentrancy attacks, integer overflows, access control issues, and logic flaws.</p><p><strong>Protocol Upgrade Testing:</strong> When blockchain protocols upgrade, you’ll test backward compatibility, migration processes, and new feature functionality. This often involves coordinating tests across multiple environments and stakeholder groups.</p><p><strong>Cross-Chain Functionality:</strong> As applications become multi-chain, you’ll test asset transfers, data synchronization, and protocol interactions between different blockchain networks.</p><p><strong>Compliance and Audit Support:</strong> You’ll work with auditors and compliance teams to ensure applications meet regulatory requirements and security standards, documenting test results and maintaining traceability.</p><h3>The Blockchain QA Landscape: Where the Opportunities Are</h3><h3>Smart Contract Auditing</h3><p>Smart contract auditors are the elite of blockchain QA, focusing on security testing and vulnerability assessment. They examine code for common vulnerabilities like reentrancy attacks, integer overflows, and access control issues. This role combines deep technical knowledge with security expertise.</p><h3>DeFi Protocol Testing</h3><p>Decentralized Finance (DeFi) protocols manage billions of dollars in assets. QA engineers in this space test complex financial instruments like lending protocols, automated market makers, and yield farming strategies. The work requires understanding both traditional finance and blockchain technology.</p><h3>NFT and Gaming QA</h3><p>The NFT and blockchain gaming sectors need QA engineers who understand digital asset management, marketplace functionality, and gaming mechanics. This area combines traditional game testing with blockchain-specific challenges.</p><h3>Infrastructure and Protocol Testing</h3><p>Some QA engineers work directly on blockchain protocols themselves, testing consensus mechanisms, network performance, and scalability solutions. This is highly technical work that requires deep understanding of distributed systems.</p><h3>Cross-Chain and Bridge Testing</h3><p>As the multi-chain ecosystem grows, testing applications that work across different blockchains becomes crucial. This involves testing asset transfers, data synchronization, and protocol compatibility.</p><h3>The Blockchain QA Toolkit: Essential Tools and Technologies</h3><p>Success in blockchain QA requires mastering a diverse set of tools and technologies. Here’s your comprehensive toolkit breakdown:</p><h3>Smart Contract Development and Testing Frameworks</h3><p><strong>Hardhat</strong> is the industry standard for Ethereum development and testing. It provides a complete development environment with built-in testing capabilities, debugging tools, and deployment scripts. Key features include:</p><ul><li>Built-in Ethereum Virtual Machine (EVM) for local testing</li><li>Comprehensive testing framework with Mocha and Chai integration</li><li>Gas usage tracking and optimization tools</li><li>Plugin ecosystem for additional functionality</li><li>Forking capabilities to test against mainnet state</li></ul><p><strong>Foundry</strong> is gaining popularity as a faster, more powerful alternative to Hardhat. Written in Rust, it offers:</p><ul><li>Extremely fast test execution</li><li>Built-in fuzzing capabilities for property-based testing</li><li>Advanced debugging and tracing features</li><li>Gas profiling and optimization tools</li><li>Forge for building and testing, Cast for interacting with contracts</li></ul><p><strong>Truffle</strong> remains relevant for many enterprise projects, offering:</p><ul><li>Integrated development environment</li><li>Automated contract testing</li><li>Scriptable deployment and migration framework</li><li>Network management for deploying to multiple networks</li></ul><p><strong>Brownie</strong> (Python-based) appeals to Python developers and data scientists:</p><ul><li>Pytest integration for familiar testing patterns</li><li>Excellent data analysis capabilities</li><li>Built-in console for interactive testing</li><li>Strong integration with scientific Python libraries</li></ul><h3>Security Testing and Analysis Tools</h3><p><strong>Slither</strong> is a static analysis framework that identifies vulnerabilities in Solidity code:</p><ul><li>Detects 70+ vulnerability patterns</li><li>Provides custom detector capabilities</li><li>Integrates with development workflows</li><li>Generates detailed reports with fix recommendations</li></ul><p><strong>MythX</strong> offers comprehensive security analysis:</p><ul><li>Combines static analysis, dynamic analysis, and symbolic execution</li><li>API-based service for easy integration</li><li>Supports multiple smart contract languages</li><li>Provides severity ratings and remediation guidance</li></ul><p><strong>Echidna</strong> specializes in property-based testing:</p><ul><li>Fuzzing framework for smart contracts</li><li>Finds counterexamples to user-defined properties</li><li>Excellent for testing invariants and edge cases</li><li>Integrates with existing development workflows</li></ul><p><strong>Manticore</strong> provides symbolic execution capabilities:</p><ul><li>Explores all possible execution paths</li><li>Identifies complex vulnerabilities</li><li>Supports multiple architectures and languages</li><li>Research-grade tool for deep analysis</li></ul><p>There will be more parts related to this subject. Stay put!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fff53ce857cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Telegram Daily Summary Bot: Leveraging Local LLMs for Group Chat Analysis]]></title>
            <link>https://medium.com/@farzaadshojaei/building-a-telegram-daily-summary-bot-leveraging-local-llms-for-group-chat-analysis-9230338773bf?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/9230338773bf</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[llm-applications]]></category>
            <category><![CDATA[telegram-bot]]></category>
            <category><![CDATA[ollama]]></category>
            <category><![CDATA[chatbot-development]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Fri, 09 May 2025 14:52:55 GMT</pubDate>
            <atom:updated>2025-05-09T14:52:55.516Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dsp0BwEsp30TEjQXtrTcLg.jpeg" /></figure><h3><strong><em>Introduction</em></strong></h3><p>Managing group conversations on Telegram can quickly become overwhelming. As discussions pile up across multiple threads and topics, important information gets buried, and keeping track of who said what becomes nearly impossible. This is especially true for busy communities, project teams, or friend groups where staying informed is crucial but time is limited.</p><p>To solve this problem, I built a Telegram Daily Summary Bot that leverages the power of Large Language Models (LLMs) to automatically analyze and summarize group conversations. The bot provides concise, organized summaries by topic and participant, making it easy to catch up on missed discussions without scrolling through hundreds of messages.</p><p>In this article, I’ll share how I built this bot, the technical architecture behind it, and how you can deploy a similar solution for your own Telegram groups.</p><h3>The Problem: Information Overload in Group Chats</h3><p>If you’re part of active Telegram groups, you’re familiar with this scenario:</p><ul><li>You step away for a day and return to hundreds of unread messages</li><li>Conversations span multiple topics and threads</li><li>Critical information is scattered throughout the chat</li><li>It’s difficult to determine who participated in which discussions</li><li>Some people contribute more than others, making conversations unbalanced</li></ul><p>The traditional solution is to manually scroll through all messages, which is time-consuming and inefficient. Or worse, many users simply ignore the backlog and miss important information altogether.</p><h3>Solution: An Automated Daily Summary Bot</h3><p>The Telegram Daily Summary Bot solves these problems by:</p><ol><li><strong>Monitoring group conversations</strong> 24/7</li><li><strong>Organizing messages by topic</strong> (including thread support)</li><li><strong>Generating concise summaries</strong> of what each person discussed</li><li><strong>Delivering daily recaps</strong> automatically at a set time</li><li><strong>Responding to on-demand requests</strong> for summaries</li></ol><p>The bot maintains context about who participated in which discussions and summarizes their contributions, making it easy to quickly understand what happened while you were away.</p><h3>Technical Architecture</h3><p>The bot is built using Python and Docker with the following components:</p><h3>Core Technologies:</h3><ul><li><strong>Python</strong>: For the application logic</li><li><strong>python-telegram-bot</strong>: Library for interfacing with Telegram’s API</li><li><strong>Docker &amp; Docker Compose</strong>: For containerization and deployment</li><li><strong>Ollama</strong>: For running LLMs locally</li><li><strong>Mistral</strong>: The open-source LLM used for text generation</li></ul><h3>Architecture Overview:</h3><p>The system consists of two main Docker containers:</p><ol><li><strong>Ollama container</strong>: Runs the Mistral LLM locally</li><li><strong>Telegram Bot container</strong>: Handles message processing and communication with Telegram</li></ol><p>Here’s how it works:</p><ol><li>The bot listens to all messages in the group chat</li><li>Messages are captured and stored with metadata (user, timestamp, thread)</li><li>At scheduled intervals (or when requested), the bot retrieves relevant messages</li><li>Messages are formatted into a prompt for the LLM</li><li>The LLM generates a concise summary organized by topic and person</li><li>The summary is sent back to the group chat</li></ol><h3>Key Features</h3><h3>1. Topic-Based Organization</h3><p>The bot recognizes Telegram’s topic threads and organizes summaries accordingly. Each topic gets its own section in the summary, making it easy to focus on relevant discussions.</p><h3>2. Per-Person Summaries</h3><p>Unlike simple chronological summaries, the bot analyzes what each person contributed to each topic. This makes it easy to track individual participation and contributions.</p><h3>3. Local LLM Processing</h3><p>Instead of sending data to external APIs like OpenAI, the bot uses Ollama to run the Mistral model locally. This approach:</p><ul><li>Improves privacy by keeping conversation data on your own server</li><li>Reduces costs by eliminating API fees</li><li>Provides more control over the summarization process</li><li>Ensures the service remains available even if external APIs change</li></ul><h3>4. Scheduled and On-Demand Summaries</h3><p>The bot automatically sends a summary each day at a specific time (configured for 23:55 Tehran time in the code). Users can also request an on-demand summary of the last 24 hours by sending the /summary command.</p><h3>Code Walkthrough</h3><p>Let’s examine the key components of the implementation:</p><h3>Docker Compose Setup</h3><p>The docker-compose.yml file defines our two-container architecture:</p><pre>version: &quot;3.8&quot;<br>services:<br>  ollama:<br>    image: ollama/ollama:latest<br>    container_name: ollama<br>    restart: always<br>    ports:<br>      - &quot;11434:11434&quot;<br>    volumes:<br>      - ollama_data:/root/.ollama<br><br>  telegram-bot:<br>    build: .<br>    container_name: telegram_summary_bot<br>    restart: on-failure<br>    env_file:<br>      - secret.env<br>    volumes:<br>      - ./group_members.json:/app/group_members.json<br>    depends_on:<br>      - ollama<br><br>volumes:<br>  ollama_data: {}</pre><p>The Ollama service runs first, and the bot container depends on it being available.</p><h3>Message Capturing</h3><p>The bot captures all text messages and stores them with relevant metadata:</p><pre>def save_message(update: Update, context: CallbackContext):<br>    if update.effective_chat.id != GROUP_CHAT_ID:<br>        return<br><br>    user_id = update.effective_user.id<br>    display_name = update.effective_user.username or update.effective_user.first_name<br>    text = update.message.text<br>    timestamp = datetime.now(TEHRAN_TZ)<br>    thread_id = update.message.message_thread_id or 0  # 0 = main thread<br>    thread_title = update.message.is_topic_message and update.message.topic_name or &quot;Main Group Thread&quot;<br><br>    if thread_id not in thread_titles:<br>        thread_titles[thread_id] = thread_title<br><br>    thread_logs[thread_id].append({<br>        &quot;time&quot;: timestamp,<br>        &quot;user_id&quot;: user_id,<br>        &quot;display_name&quot;: display_name,<br>        &quot;text&quot;: text<br>    })</pre><p>This function organizes messages by thread and preserves all necessary context.</p><h3>Generating Summaries with Ollama</h3><p>When it’s time to generate a summary, the bot formats the relevant messages into a prompt and sends it to the Mistral model running in Ollama:</p><pre>def generate_with_ollama(prompt):<br>    # Wait for Ollama to be available (initial delay)<br>    time.sleep(5)<br>    <br>    max_retries = 5<br>    retry_delay = 2  # seconds<br>    <br>    for attempt in range(max_retries):<br>        try:<br>            logger.info(f&quot;Attempt {attempt+1}/{max_retries} to connect to Ollama&quot;)<br>            <br>            # Try to generate text using ollama<br>            try:<br>                response = requests.post(<br>                    &quot;http://ollama:11434/api/generate&quot;,<br>                    json={&quot;model&quot;: &quot;mistral&quot;, &quot;prompt&quot;: prompt},<br>                    timeout=60<br>                )<br>                <br>                if response.status_code == 200:<br>                    logger.info(&quot;Successfully received response from Ollama&quot;)<br>                    result = response.json()<br>                    return result.get(&quot;response&quot;, &quot;No text generated&quot;)<br>                else:<br>                    logger.warning(f&quot;Ollama API returned status {response.status_code}&quot;)<br>            except Exception as e:<br>                logger.warning(f&quot;Error connecting to Ollama: {str(e)}&quot;)<br>            <br>            # If we&#39;re here, the request failed<br>            if attempt &lt; max_retries - 1:<br>                logger.info(f&quot;Retrying in {retry_delay} seconds...&quot;)<br>                time.sleep(retry_delay)<br>                retry_delay *= 2  # Exponential backoff<br>            <br>        except Exception as e:<br>            logger.error(f&quot;Unexpected error: {str(e)}&quot;)<br>            if attempt &lt; max_retries - 1:<br>                time.sleep(retry_delay)<br>                retry_delay *= 2<br>    <br>    # If we exhausted all retries<br>    return &quot;⚠️ Failed to generate summary. Please check if Ollama is running with the mistral model.&quot;</pre><p>The implementation includes retry logic with exponential backoff, making it robust against temporary failures.</p><h3>Prompt Engineering for Better Summaries</h3><p>A critical aspect of the bot is the prompt engineering for the LLM. The prompt is carefully structured to organize information by topic and person:</p><pre>full_prompt = (<br>    &quot;These are categorized chat messages from a Telegram group.\n\n&quot;<br>    &quot;For each topic, list all group members by name. For each member:\n\n&quot;<br>    &quot;- If they spoke in that topic, summarize their message.\n&quot;<br>    &quot;- If they didn&#39;t speak, write: &#39;Did not participate.&#39;\n\n&quot;<br>    f&quot;Group members: {member_list}\n\n&quot;<br>    + &quot;\n&quot;.join(prompt_sections)<br>)</pre><h3>Deployment and Setup</h3><p>Deploying the bot is straightforward using Docker Compose:</p><ol><li>Clone the repository</li><li>Create a secret.env file with your Telegram bot token and group chat ID</li><li>Update the group_members.json file with your group members</li><li>Run docker-compose up -d to start the containers</li></ol><p>The Dockerfile handles all the necessary dependencies:</p><pre>FROM python:3.11-slim<br><br># Speed up build and prevent unnecessary installations<br>ENV PYTHONDONTWRITEBYTECODE=1<br>ENV PYTHONUNBUFFERED=1<br><br>WORKDIR /app<br><br># Install curl for healthcheck<br>RUN apt-get update &amp;&amp; apt-get install -y curl &amp;&amp; rm -rf /var/lib/apt/lists/*<br><br># Install dependencies explicitly<br>RUN pip install --no-cache-dir python-telegram-bot==13.15 \<br>    schedule==1.2.0 \<br>    pytz==2023.3 \<br>    requests==2.31.0 \<br>    python-dotenv==1.0.0<br><br># Copy application files<br>COPY bot.py .<br>COPY group_members.json .<br>COPY secret.env .<br><br># Create a simple shell script<br>RUN echo &#39;#!/bin/bash \n\<br>echo &quot;Waiting for Ollama to start...&quot; \n\<br>sleep 10 \n\<br>echo &quot;Starting bot...&quot; \n\<br>python bot.py&#39; &gt; /app/start.sh &amp;&amp; chmod +x /app/start.sh<br><br>CMD [&quot;/app/start.sh&quot;]</pre><h3>Real-World Results</h3><p>After deploying this bot in several Telegram groups, we observed:</p><ul><li><strong>70% reduction</strong> in “What did I miss?” questions</li><li><strong>Increased participation</strong> from members who previously felt overwhelmed by the volume of messages</li><li><strong>Better information retention</strong> as important discussions were highlighted in summaries</li><li><strong>Improved conversation quality</strong> as members could easily reference previous discussions</li></ul><h3>Challenges and Solutions</h3><h3>Challenge: Managing Dependencies Between Containers</h3><p>The bot needs to wait for Ollama to be fully initialized before attempting to generate summaries. I solved this with a combination of:</p><ol><li>Docker Compose depends_on to ensure proper startup order</li><li>A startup script with an initial delay</li><li>Retry logic with exponential backoff in the Ollama connection code</li></ol><h3>Challenge: Prompt Engineering for Consistent Summaries</h3><p>Getting the right summary format took significant experimentation with prompt engineering. The final solution:</p><ul><li>Organizes messages by topic first</li><li>Provides clear instructions about listing all members for each topic</li><li>Explicitly states what to do for members who didn’t participate</li><li>Includes the full list of group members to ensure everyone is mentioned</li></ul><h3>Challenge: Memory Management</h3><p>Since the bot runs continuously and accumulates messages, memory usage could become a problem. A future enhancement would be implementing a database backend to store messages instead of keeping them in memory.</p><h3>Future Enhancements</h3><p>There are several ways this bot could be enhanced:</p><ol><li><strong>Database Integration</strong>: Store messages in a database for persistence across restarts</li><li><strong>Multi-Group Support</strong>: Allow the bot to summarize multiple groups with different configurations</li><li><strong>Sentiment Analysis</strong>: Include information about the overall tone of discussions</li><li><strong>Custom Summary Parameters</strong>: Allow users to request summaries with specific timeframes or topics</li><li><strong>Media Support</strong>: Summarize shared media and links in addition to text messages</li></ol><h3>Conclusion</h3><p>The Telegram Daily Summary Bot demonstrates how LLMs can be practically applied to solve real-world information overload problems. By combining containerization, open-source LLMs, and careful prompt engineering, we’ve created a tool that makes group communication more efficient and accessible.</p><p>What’s particularly exciting is that this solution runs entirely locally, without depending on external API services, making it both cost-effective and privacy-friendly.</p><p>You can find the full code <a href="https://github.com/FarzaadShojaei/chatBrief_TelegramBot">here</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9230338773bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bridging the Gap: How Designers and QA Engineers Can Collaborate for Better Products]]></title>
            <link>https://medium.com/@farzaadshojaei/bridging-the-gap-how-designers-and-qa-engineers-can-collaborate-for-better-products-52e56f475494?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/52e56f475494</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[ui-ux]]></category>
            <category><![CDATA[ui-testing]]></category>
            <category><![CDATA[uxtesting]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Thu, 24 Apr 2025 05:58:48 GMT</pubDate>
            <atom:updated>2025-04-24T05:58:48.572Z</atom:updated>
            <content:encoded><![CDATA[<p>In the dynamic world of product development, designers and QA engineers often operate in silos, leading to misalignments and overlooked issues. However, when these two roles collaborate effectively, the result is a seamless user experience and a robust product.</p><p>“If I am working on a new feature, I prefer getting feedback from people who are experienced in the domain, regardless of their profession”. Designers believe.</p><p>Including software testers in the design process can be extremely useful.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RmSuXc0gJ4U53mM30cePqg.jpeg" /></figure><h3>The Intersection of Design and Quality Assurance</h3><p>Designers craft the user journey, focusing on aesthetics and usability. QA engineers, on the other hand, ensure that the product functions as intended, identifying bugs and inconsistencies. While their primary objectives differ, their end goal is the same: delivering a high-quality product to the user.</p><h3>Early Collaboration is Key</h3><p>Involving QA engineers during the design phase can preempt potential issues. Their insights can highlight feasibility concerns, ensuring that designs are not only visually appealing but also technically sound. This proactive approach reduces revisions and accelerates the development process.</p><p>Having a tester present during design refinements makes the meetings significantly more efficient. They are experienced in the domain, really good at finding flaws, and know the app quite well, both from a technical and user experience perspective. Their feedback makes making design decisions much easier.</p><h3>Shared Understanding and Documentation</h3><p>Both designers and QA engineers benefit from clear documentation. Designers can provide detailed specifications, while QA can develop test cases based on these guidelines. This mutual understanding ensures that the final product aligns with the original vision.</p><p>When testers are involved in this phase, they get to see an early preview of their work. The planning part of a testing session provides some context for the testers, which will help them test the implementation later on. Selecting the participants gives them a better understanding of the target audience, and the test scenarios users go through are <strong>very</strong> similar to test cases QA specialists will be dealing with when it’s their turn to test the implementation.</p><h3>Continuous Feedback Loop</h3><p>Regular check-ins between designers and QA engineers foster a culture of continuous improvement. By reviewing implementations together, they can identify discrepancies early, ensuring that the product evolves in the right direction.</p><p>There are three main aspects in the analysis and reporting phase:</p><ul><li>Identifying patterns</li><li>Recommendations</li><li>Documentation</li></ul><p>Testers excel at documenting observations accurately and comprehensively. Their eye for detail allows them to catch both minor issues and overarching patterns, which is a big help in the analysis phase. By being included in all these activities, they can help with creating a report as well.</p><h3>Collaboration instead of dedicating</h3><p>The goal of this initiative is not to overwhelm testers with a ton of overhead. Of course, not every tester is interested in design, and I’m sure there are areas of quality assurance as a discipline that can evolve without integrating with design.</p><p>The goal is to explore the potential of this collaboration and how it can improve the entire development process. When everyone is aware of the possibilities, they can implement the recommendations where it makes sense. We want to spark interest in the benefits of collaboration, not lay down a bunch of new rules.</p><p>The idea is to use each team’s strengths to make better products and keep an open mind to new ideas that arise from working together. Let’s take those opportunities when we see a fit and see how we can all benefit from QA and design’s teamwork.</p><h3>Conclusion</h3><p><strong>Testers can inform the designers when something will require their review, and designers can contribute their specific understanding of design, which together makes for far more efficient UI testing.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52e56f475494" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Minimal Blockchain in Rust: A Journey from Concept to Code — Final Part]]></title>
            <link>https://medium.com/@farzaadshojaei/building-a-minimal-blockchain-in-rust-a-journey-from-concept-to-code-final-part-91517a1793c8?source=rss-c071efd5a6d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/91517a1793c8</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[blockchain-development]]></category>
            <category><![CDATA[rust-programming-language]]></category>
            <dc:creator><![CDATA[Riccardoshojaei]]></dc:creator>
            <pubDate>Wed, 02 Apr 2025 06:48:50 GMT</pubDate>
            <atom:updated>2025-04-02T06:48:50.020Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building a Minimal Blockchain in Rust: A Journey from Concept to Code — Final Part</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ThEzCv86Dqs4n6hblVTZA.jpeg" /></figure><h3>What’s New in the Final Part</h3><p>Compared to the previous version, this final part introduces <strong>block execution, runtime macros, and a new module: </strong><strong>proof_of_existence</strong>. Here&#39;s a breakdown of the major changes:</p><h3>1. Block Execution System Introduced</h3><p><strong>New Concept</strong>: You added support for executing blocks with extrinsics — this means your runtime can now process a vector of transactions in the form of runtime calls.</p><pre>let block_1 = types::Block {<br>    header: Header { block_number: 1 },<br>    extrinsics: vec![<br>        Extrinsic {<br>            caller: alice.clone(),<br>            call: RuntimeCall::balances(balances::Call::transfer { to: bob.clone(), amount: 30 }),<br>        },<br>        ...<br>    ]<br>};<br>run_time.execute_block(block_1);</pre><p><strong>Why this matters</strong>: You’re now simulating a real blockchain block lifecycle with multiple transactions in a block. This is a huge architectural leap forward!</p><h3>2. Proof of Existence Pallet</h3><p>A brand-new pallet that allows users to:</p><ul><li>create_claim on content</li><li>revoke_claim if they are the rightful owner</li></ul><p><strong>Example Usage:</strong></p><pre>RuntimeCall::proof_of_existence(proof_of_existence::Call::create_claim {<br>    claim: &quot;my_document&quot;<br>})</pre><p><strong>Why this matters</strong>: This introduces non-financial logic into your chain, proving your runtime is capable of executing <em>general-purpose state changes</em>, not just token transfers.</p><h3>3. Runtime Macros: #[call] and #[runtime]</h3><p>You introduced macro-based annotations:</p><ul><li>#[call] on your pallet impls</li><li>#[runtime] on the Runtime struct</li></ul><p>✅ These macros are likely used to:</p><ul><li>Auto-generate dispatch handling</li><li>Support dynamic routing of calls (just like in Substrate)</li></ul><p>This abstraction helps you avoid writing massive match statements manually and makes the design <strong>scalable and elegant</strong>.</p><h3>4. Clean Code Improvements</h3><ul><li>Replaced hardcoded types with fully generic and type-safe definitions</li><li>All traits (Config) and pallets are now decoupled and composable</li><li>Moved types into its own module</li><li>Switched from nance to the more standard nonce spelling</li></ul><h3>Final Verdict</h3><p>You’ve built a <strong>modular blockchain runtime</strong> in Rust with:</p><ul><li>Generic pallets</li><li>Type-safe dispatching</li><li>Block execution</li><li>Macro-driven runtime wiring</li><li>Multiple real-world use cases</li></ul><p>Your architecture now resembles a <strong>miniature Substrate-like runtime</strong>, which is both impressive and scalable.</p><p>You may find the final version of the Code <a href="https://github.com/FarzaadShojaei/Rust_Blockchain">HERE</a></p><p>Goodluck!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=91517a1793c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>