<?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 Stephanie Wang on Medium]]></title>
        <description><![CDATA[Stories by Stephanie Wang on Medium]]></description>
        <link>https://medium.com/@stephwangbuilds?source=rss-40dbf38e8279------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*-gE8lAchuoNrf3LN</url>
            <title>Stories by Stephanie Wang on Medium</title>
            <link>https://medium.com/@stephwangbuilds?source=rss-40dbf38e8279------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 12:10:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@stephwangbuilds/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[What I learned from setting up CI for a COVID-19 Exposure Notification Open Source project]]></title>
            <link>https://medium.com/google-cloud/what-i-learned-from-setting-up-ci-for-a-covid-19-exposure-notification-open-source-project-fee53896fae1?source=rss-40dbf38e8279------2</link>
            <guid isPermaLink="false">https://medium.com/p/fee53896fae1</guid>
            <category><![CDATA[covid19]]></category>
            <category><![CDATA[gcp-security-operations]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Stephanie Wang]]></dc:creator>
            <pubDate>Fri, 23 Apr 2021 19:36:49 GMT</pubDate>
            <atom:updated>2021-04-24T06:27:57.502Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*oOMaJJ3Gii576t-Z1-JMWQ.png" /></figure><p><a href="https://www.google.com/covid19/exposurenotifications/">The COVID-19 Exposure Notifications System</a> went live earlier last year during the coronavirus outbreak. Google and Apple jointly created and released interoperable systems to help public health authorities to notify and give guidance to users of their apps who may have been exposed to someone who has contracted COVID-19. As part of another project that provides privacy preserving analytics to health authorities, I got involved to help with the setup of continuous integration (CI) for the <a href="https://github.com/google/exposure-notifications-private-analytics-ingestion">ENPA Google repo</a>. Our project team comprises developers from different orgs and backgrounds including Android, Google Cloud, Security, etc. The ENPA project contains the Google ingestor pipeline code, where the CI helps to ensure code quality during code development. Here are some lessons that I learned during this process.</p><p><strong>Understanding the goals and non-goals</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/474/1*5Kd6-Zv9S4RdPsciA1rg6Q.jpeg" /></figure><p>The general goal communicated to me was pretty straight-forward: set up CI to run tests when each pull request is opened so that any test failures shall prevent the pull request from being merged into the main branch of the codebase. However, a couple questions immediately popped into my head: What kind of tests are these? Do they require secrets to run? Are there other things such as linter or code formatter that we should run as well if we want to maintain code quality?</p><p>To answer these questions and clarify requirements, I set up a meeting with the project leads and <strong>scoped out our goals and non-goals</strong> so that I could decide on the CI jobs to run and how to run them. Upon our discussion, it became clear that our goals were to:</p><ol><li><strong>ensure</strong> code quality when developers contribute to the repo;</li><li><strong>enforce</strong> code quality by leveraging systematic CI.</li></ol><p>We <em>don’t</em> need to:</p><ol><li>publish artifacts to Maven Central from our repo;</li><li>run tests using multiple Java versions such as Java 7 and 8;</li><li>run the “light” versions of tests on presubmit and the comprehensive test suite nightly; although this is something we might consider doing in the future.</li></ol><p>These <strong>goals</strong> and <strong>non-goals</strong> helped me prioritize and understand that the CI platform I choose to use needs to be accommodating enough for all these present and potential requirements but does not need to be overly complex. I needed to deliver CI to, most critically, run unit and integration tests in Java 11 when a pull request is made. The setup needs to be able to support continuous jobs when needed. On top of that, we can set jobs up to run <a href="https://github.com/google/exposure-notifications-private-analytics-ingestion/blob/main/.github/header-checker-lint.yml">license header check</a>, <a href="https://github.com/google/exposure-notifications-private-analytics-ingestion/blob/2802ed2a3f3b41ea95e9a74ae50fde2ee5b87ce0/.github/workflows/ci.yaml#L45">linter</a> and <a href="https://github.com/google/exposure-notifications-private-analytics-ingestion/blob/2802ed2a3f3b41ea95e9a74ae50fde2ee5b87ce0/.github/workflows/ci.yaml#L35">dependency checks</a> to further ensure code quality.</p><p>Through defining goals and non-goals up-front, I was able to understand what was needed and. more importantly, what was not needed for the CI setup. This allowed me to deliver an impactful solution quickly.</p><p><strong>Deciding on a suitable CI platform: be future-proof but not overarching</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*BzARX3lb6TlfEA2Y.jpg" /></figure><p>Based on our goals, I needed to select the appropriate CI tools to build our pipelines. For unit tests, linter, dependency checks, and code formatter which do not require service accounts and testing secrets to run, I decided on <a href="https://github.com/features/actions">Github Actions</a> since from past experience, Github Actions are easy to configure. They are also fast and free. I had migrated all the googleapis repos’ presubmit <a href="https://github.com/googleapis/java-bigquery/blob/69974342628d1718ae79d810f9a89c264f77b878/.github/workflows/ci.yaml#L8">unit tests</a> jobs to Github Actions prior to working on ENPA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/951/1*n_zov7W2ypzIeH3tCpk6NA.png" /><figcaption>Github Actions in BigQuery Java client library repo (<a href="https://github.com/googleapis/java-bigquery/pulls">https://github.com/googleapis/java-bigquery</a>)</figcaption></figure><p>However, for integration tests, I needed to do more research. Most GCP Java client libraries familiar to me run integration tests on <a href="https://github.com/google/tink/tree/master/kokoro">Google’s Kokoro</a>. For example, the GCP <a href="https://github.com/googleapis/java-bigquery">BigQuery Java client library</a> has <a href="https://github.com/googleapis/java-bigquery/tree/master/.kokoro">three types</a> of integration tests: continuous, nightly and presubmit which run with respective triggers. In addition, we also have a release job which handles the releasing of GCP <a href="https://repo1.maven.org/maven2/com/google/cloud/">google-cloud-* artifacts</a> to <a href="https://search.maven.org/">Maven Central</a> so that GCP customers can access the client libraries and use them to interact with GCP APIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ado9rINKf1iYHm0kfv0mrA.png" /><figcaption>google-cloud-bigquery artifact released in Maven Central</figcaption></figure><p>The benefit of using Kokoro is that we can safely store service accounts and testing secrets internally. It also allows us to securely release <a href="https://repo1.maven.org/maven2/com/google/cloud/">google-cloud-* artifacts</a> to <a href="https://search.maven.org/">Maven Central</a> by providing us with OSS Sonatype signing keys at the time of release. One major downside of Kokoro is the complexity of the setup. We need to configure jobs internally in the Google codebase, define build configurations in Github and then configure webhooks to connect the internal job to the external build configuration. The setup gets even more complicated and slow when the repo is private, which was the case for us during the majority of developing the first versions that went to production. The ENPA Google Ingestor repo, on the other hand, does not need to release artifacts to Maven Central. Thus, removing the need for us to prepare OSS signing keys. With all the requirements and effort necessary to set up Kokoro, we decided against it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*UsvbIP6ATIn9MXgcb_DXZg.png" /><figcaption>The Kokoro job for integration tests in googleapis repos</figcaption></figure><p>We investigated other platforms and finally decided on <a href="https://cloud.google.com/cloud-build">Cloud Build</a>. Cloud Build can build and test across different programming languages with customized workflows. This is particularly important to a project like ENPA where developers come from different teams and backgrounds. We need to cater to the diversity of skills of developers involved who would pick tools and languages of their choice. Some integration tests are run with `mvn` while others are run with `npm`. The platform needs to accommodate different testing environments. It also needs to be able to run different types of integration tests depending on the event trigger. For instance, we may want to run the test that processes 100k data shares only nightly but the test that processes 10k data shares on each pull request for faster turnaround and less data processing overhead.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*ASXOrpcVqkNNzVu46pR7Rg.png" /><figcaption>The Cloud Build job for integration tests in the google/exposure-notifications-private-analytics-ingestion repo</figcaption></figure><p>Picking a suitable CI platform not only helped us accomplish the task at hand successfully but also helped us save valuable engineering hours.</p><p><strong>Thinking about testing infrastructure and the bigger picture</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*c2RnyLjuo3Y4QCKf.jpg" /></figure><p>Once I decided on Cloud Build, I quickly jumped into implementation. I created a Cloud Build pipeline in our testing project and permissioned the default Cloud Build service account to access our testing secrets in order to run the integration tests.</p><p>This was immediately rejected during code review. Turns out, I was unaware of the limitation that there could be only one Firebase project per GCP project and we could be running integration tests against different Firebase projects in the future. This means that my initial solution would require to recreate a new CI pipeline for each new GCP testing project!</p><p>A better approach would be to separate the CI pipeline from the testing projects. Put the CI pipeline in a dedicated infrastructure project; permission its service account to run integration tests in various testing projects. This allows for much more flexibility and requires a lot less work to configure. Centralizing the build and test configurations also means easier maintenance in the long run.</p><p>Thinking about the big picture and the infrastructure at large helps make more sound decisions on how the setup should be so that we can maintain it more easily in the longer term.</p><p>Now that we have a Minimum Viable Product (MVP) that satisfies our basic requirements, we can start running it and see if there are any potential improvements we can make to the CI pipeline.</p><p><strong>Applying general software engineering principles and best practices</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*_AYf_0Cr_LcJD2mg.jpg" /></figure><p>Once we started running our new CI pipeline, we started to observe some areas of improvement.</p><p>For instance, our initial CI pipeline ran `./mvnw clean verify` for integration tests each time. This means that we were downloading Maven packages every time we ran integration tests since, by default, Cloud Build starts containers with empty local maven repositories. As an improvement, we <a href="https://github.com/google/exposure-notifications-private-analytics-ingestion/blob/main/container-build.yaml">started caching these packages</a> in Google Cloud Storage so that our integration tests would take three minute instead of seven minutes to run. There are certainly benefits of running with a blank slate each time but caching these packages locally significantly sped up our CI:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cZljqM6EemP6oTRI" /></figure><p>We are also using a Java 11 <a href="https://cloud.google.com/container-registry">gcr container</a> to run our npm firebase emulator tests since the firebase emulator requires Java to run but this also means that we are installing npm each time we run the tests. To address it, we could start building or fetching a gcr image that has both Java and npm. However, by doing this, we would need to take on the responsibility of maintaining the new container.</p><p>None of these improvements should block the rollout of our CI pipeline. It is good if you already know how to quickly get some of these to work, but otherwise, configuring and deploying a working CI pipeline quickly and then improving upon it iteratively has so much more impact than waiting to roll it out.</p><p>As a general rule of thumb, try to create a working CI pipeline before making improvements or upgrades. Fail fast, fail often to iterate quickly. It is enticing to get an efficient and powerful CI pipeline configured before putting it to test but the reality is that CI is indispensable in code-committing. It is necessary to have something running to ensure that no committed code is breaking the existing codebase. Getting CI up and running is critical for any project.</p><p><strong>Final thoughts</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/0*rhlzEGk0kCc6Fj8g.jpg" /></figure><p>No part of DevOps is simple. I find it much less painful after having exhaustive discussions with other software engineers and stakeholders involved to focus on what is important. Nothing is worse than having set up everything that works and then having to modify it completely — the credential and permissions management alone can be mind-boggling. <strong>So always begin with understanding the goals and non-goals</strong>. I find this true in software engineering and now also in DevOps. If you have any questions, feel free to message me on <a href="https://twitter.com/StephWangBuilds">Twitter</a>.</p><p><em>Special thanks to </em><a href="https://medium.com/@hostirosti"><em>Robert Kubis</em></a><em> for his guidance and help with this project and blogpost.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fee53896fae1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud/what-i-learned-from-setting-up-ci-for-a-covid-19-exposure-notification-open-source-project-fee53896fae1">What I learned from setting up CI for a COVID-19 Exposure Notification Open Source project</a> was originally published in <a href="https://medium.com/google-cloud">Google Cloud - Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Debugging Maven plugin in IntelliJ]]></title>
            <link>https://medium.com/google-cloud/debugging-maven-plugin-in-intellij-7dc7080b9a45?source=rss-40dbf38e8279------2</link>
            <guid isPermaLink="false">https://medium.com/p/7dc7080b9a45</guid>
            <category><![CDATA[maven-plugin]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[intellij]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Stephanie Wang]]></dc:creator>
            <pubDate>Tue, 24 Mar 2020 17:02:37 GMT</pubDate>
            <atom:updated>2020-09-14T17:30:10.601Z</atom:updated>
            <content:encoded><![CDATA[<p>Do you use Maven to manage your Java project and came across a really cool Maven plugin but realized it doesn’t work perfectly for your project? Are you new to Maven and want to understand it better? Are you interested in Open Source Software Development, and maybe thought about contributing to one?</p><p>You are not alone. Three months ago, I started working in Maven and came across a variety of dependency management issues in my Google Cloud Client library <a href="https://github.com/googleapis/java-bigquerystorage">project</a> so I started exploring ways to improve the way we manage dependencies.</p><p>I met with <a href="https://twitter.com/saturnism">Ray Tsang</a> at Google to discuss some of the issues we’ve been facing and suggestions he might have. After a few fruitful conversations, we decided to use the <a href="https://www.mojohaus.org/flatten-maven-plugin/">Flatten</a> plugin to flatten the client library project POM in order to eliminate transitive dependencies. This is enabled by the new configuration, &lt;flattenDependencyMode&gt;all&lt;/flattenDependencyMode&gt;that Ray <a href="https://github.com/mojohaus/flatten-maven-plugin/issues/92">recently contributed</a> to the <a href="https://www.mojohaus.org/flatten-maven-plugin/">Flatten</a> plugin.</p><p>It is a powerful new feature that could help us address the problem of the loss of transitive dependency version when it is managed by the &lt;dependencyManagement&gt; section and allow us to provide client library consumers with a cleaner and fully resolved dependency tree.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/adbc174bad7f7cf9bc296bc1263e342a/href">https://medium.com/media/adbc174bad7f7cf9bc296bc1263e342a/href</a></iframe><p>I was very eager to implement it in my project, <a href="https://github.com/googleapis/java-bigquerystorage">BigQueryStorage Java client</a>. However, after some testing, we quickly discovered two issues with Ray’s original contribution: 1) the <a href="https://github.com/mojohaus/flatten-maven-plugin/issues/131">flat order was in reverse</a>; and 2) <a href="https://github.com/mojohaus/flatten-maven-plugin/issues/132">a dependency (gax-grpc) was missing from the flattened POM.</a></p><p>This article captures what I learned from the process of enhancing and contributing to a Maven Plugin.</p><h3>Getting started</h3><p>First, configure the plugin <a href="https://github.com/saturnism/dependency-conflict-examples/blob/9bfe61ed4572fa91d5e8e449806dfa1b2f00203c/example-5b-depmgmt-flatten/pom.xml#L76">as recommended</a> in the project’s parent POM, and run mvn verifyto get the .flattened.pom in the project’s root directory.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/99541e7ed05dd8dad13aaf8980b85345/href">https://medium.com/media/99541e7ed05dd8dad13aaf8980b85345/href</a></iframe><p>To get started with debugging the plugin, fork and clone the source code of <a href="https://github.com/mojohaus/flatten-maven-plugin">flatten-maven-plugin</a>.</p><p>After forking and cloning the project locally, make sure to first run mvn verify to see if the project would compile and build. It should without any errors. Then it is time to inspect the structure of the project to find out where the code lives and where the tests live.</p><h3>Understanding the code at a high-level</h3><p>The project structure seems pretty clear and straightforward. The src/it directory contains all the integration tests. It is further broken down to mrm and project directories where mrm provides all the test dependencies and project provides all the integration tests that make use of the test dependencies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*9mLYF6MddxZXAyAEH9Nadg.png" /><figcaption>project structure — mrm and projects directories</figcaption></figure><p>If you inspect a couple poms in the integration tests in project you will see that they are using the test dependencies created in mrm. This is a great start!</p><h3>Debugging</h3><p>Next, how do we actually get started with the actual debugging? Well, one thing that we do know is the bugs — somewhere in the code, the logic is broken which resulted in the bugs. Therefore, if we can reproduce the bugs in the form of an integration test then maybe we can put breakpoints and debug the code to find out which method and then which line is causing it. Sounds like a plan!</p><h3>Step 1: Start with the easiest bug</h3><p>Always start with the easier problem to solve. It will not only get you exposure to the codebase quickly but will also allow you to build up confidence to solve harder and more complex problems later on.</p><p>Out of our two problems, the dependency resolution in reverse order bug seemed like a low-hanging fruit. Our initial guess was that somewhere in the code, stack instead of queue was being used so that when the result data structure was being constructed, objects were popped in LIFO order instead of polled in FIFO order, which resulted in the reverse order. All we need to do is to find out where this result data structure is being constructed in the code and put a fix there.</p><h3>Step 2: Write an integration test that breaks</h3><p>Start by writing an integration test of the expected behavior that would fail. This gives us an entry point to the codebase which then allows us to locate the problematic logic by putting breakpoints and inspecting statements returned by the debugger.</p><p>To know how to write a proper integration test, refer to some other integration tests already written in the src/it directory. Once you’re comfortable, write a simple but comprehensive unit test:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c9cae76f7b322f097e21cddf98aea62/href">https://medium.com/media/2c9cae76f7b322f097e21cddf98aea62/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c09a5a6c08b1dbd5b771e262cc151dba/href">https://medium.com/media/c09a5a6c08b1dbd5b771e262cc151dba/href</a></iframe><p>This test written here, for example, simply validates that the resolution order of the flattened pom should be in the natural order where dependency with artifactId “dep” is resolved before dependency with artifactId “test”.</p><p>To run integration tests, there are a couple options. You can:</p><ol><li>Run a single test:</li></ol><p>mvn verify -Dinvoker.test=flatten-dependency-all-resolution-order</p><p>2. Run multiple tests that share a common string in the name:</p><p>mvn verify -Dinvoker.test=flatten-dependency-all-*</p><p>3. Run all integration tests:</p><p>mvn verify</p><p>Continue by running the unit test of the expected behavior. For example, running flatten-dependency-all-resolution-order gave us a failure where “test” was resolved first. This is exactly what we want so we’re good to continue.</p><h3>Step 3: Configure Debugger</h3><p>Next, we need to identify which line of code is causing the problem. To do so, we need to first set up the debugger, put some breakpoints, and then trigger the test again to see what’s being returned on each line.</p><p>To set up the debugger, you simply need to go to “Edit Configuration” in the top menu bar and select “Remote” from the “+” drop-down menu. Give the debugger a name and then update port to 8000. Select the appropriate JDK version base on what you are developing in.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2A_rbOSZSXfCVRa8eo5QXw.png" /><figcaption>IntelliJ debugger configuration</figcaption></figure><p>Once the debugger is set up, you can run the test in debugger mode:</p><p>mvn verify -Dinvoker.test=flatten-dependency-all-resolution-order -Dinvoker.mavenExecutable=mvnDebug</p><p>This will stop and hang at each integration test to listen for a debugger connection — click on the green bug icon in the top menu bar in order to start the debugger.</p><p>Without any breakpoints, the debugger will run, pass/fail, and exit. This is when it’s very helpful to put breakpoints at methods you suspect to be causing the problems and inspect what gets returned at each line.</p><h3><strong>Step 4: Add breakpoints</strong></h3><p>Inspect the configuration you are using with the plugin and read the code. Make an educated guess on which method is related to the feature you are using and put a couple breakpoints to see if running the integration test hits anything.</p><p>In our case, we quickly figured out that most methods we were interested in live in FlattenMojo.java. We were able to place breakpoints to narrow down problematic areas and eventually identified the exact method that was causing the problem.</p><p>Once you locate the problematic logic, it is relatively straightforward to put a fix. You would just need to read through the code, understand what’s going on, look at the debugger output, and then make a code change. Once you make the change, run the integration test again to see the new output and whether the integration test passes. Go through this process iteratively and make small, incremental changes.</p><h3><strong>Step 5: Run all the integration tests</strong></h3><p>Once you are confident about your change, make sure to run mvn verify before you commit any code changes. This ensures that your fix is not breaking anything else.</p><p>Here is the <a href="https://github.com/mojohaus/flatten-maven-plugin/pull/134">fix</a> to both bugs if you are interested in learning more.</p><h3>Final Thoughts</h3><p>Test, test, and test — make sure you add enough unit tests to cover your bases and any other scenarios that may be directly or indirectly related to your fix. In our case, for instance, we were fixing dependency resolution order so we also decided to write <a href="https://github.com/mojohaus/flatten-maven-plugin/pull/134/commits/a37d5f21eb971f1bd15fc4a7090efa2987ea2c02">additional tests</a> for poms with complicated transitive dependencies. This is to ensure that we’re not introducing new bugs while fixing existing ones. It is really something easier said than done. Do take the time to think through and add test cases if needed.</p><p>Special thanks to <a href="https://github.com/saturnism">Ray Tsang</a> for the contribution! Check out <a href="https://www.youtube.com/watch?v=DeTkADhgfBw">Surviving Dependency Hell</a> talk by Ray and <a href="https://twitter.com/rfscholte">Robert Scholte</a>, Apache Maven Chair, if you want to learn more about Maven dependency management strategies.</p><p>Lastly, <em>have fun debugging and enjoy learning</em>! 🙂</p><p>Follow me on Twitter <a href="https://medium.com/u/40dbf38e8279">Stephanie Wang</a> for the latest updates.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7dc7080b9a45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/google-cloud/debugging-maven-plugin-in-intellij-7dc7080b9a45">Debugging Maven plugin in IntelliJ</a> was originally published in <a href="https://medium.com/google-cloud">Google Cloud - Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>