<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hiring on miti99</title><link>https://miti99.com/en/tags/hiring/</link><description>Recent content in Hiring on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/hiring/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #55</title><link>https://miti99.com/en/post/2025/09/14/</link><pubDate>Sun, 14 Sep 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/09/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #55.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="cpu-utilization-is-a-lie"&gt;&lt;a href="https://www.brendanlong.com/cpu-utilization-is-a-lie.html" rel="noopener noreferrer"&gt;%CPU Utilization Is A Lie&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brendan Long shows that the &lt;code&gt;%CPU&lt;/code&gt; utilization metric reported by operating systems systematically understates how close a CPU actually is to saturation. He ran &lt;code&gt;stress-ng&lt;/code&gt; on a Ryzen 9 5900X (12 cores, 24 threads, with Precision Boost Overdrive enabled), sweeping load from 1% to 100% and worker counts from 1 to 24 while measuring completed operations. The results show that when the OS reports 50% CPU utilization, a general-purpose CPU workload is already at roughly 62% of its maximum throughput, 64-bit integer math is at 65–85%, matrix multiplication is at 80–100%, and an Nginx benchmark is already serving about 80% of the maximum requests per second the machine can handle.&lt;/p&gt;
&lt;p&gt;The two culprits are SMT (Hyper-Threading) and turbo clock scaling. Once active workers exceed the 12 physical cores, logical threads contend for the same core execution units so throughput stops scaling linearly; at the same time, clock speeds drop by roughly 15% when many cores are busy at once, meaning the fraction of time logical cores are busy does not equal the fraction of peak capacity used. Rather than relying on &lt;code&gt;%CPU&lt;/code&gt; to estimate headroom, the author recommends load-testing each service to find the maximum throughput a host can sustain before errors or unacceptable latency appear, tracking current real-world throughput, and comparing those two numbers directly. A practical lesson for anyone working in SRE, systems operations, or capacity planning.&lt;/p&gt;
&lt;h2 id="we-only-hire-the-trendiest"&gt;&lt;a href="https://danluu.com/programmer-moneyball/" rel="noopener noreferrer"&gt;We only hire the trendiest&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Luu examines a pervasive hiring habit in tech: companies chase candidates with &amp;ldquo;trendy&amp;rdquo; résumés—elite university degrees or brand-name employers—rather than evaluating actual engineering ability. He tells the story of Mike, an engineer with 11 years of experience laid off from Microsoft who was repeatedly rejected by an anonymized company called TrendCo for three stated reasons: irrelevant tech stack experience (because he wrote .NET), a &amp;ldquo;scattered&amp;rdquo; background, and past contract work. According to Luu, those were rationalizations; TrendCo&amp;rsquo;s typical engineer was young, relatively inexperienced, and straight out of a top-tier university, so the company unconsciously filtered for people who looked like its existing staff.
As a result, companies end up bidding against each other for a tiny pool of credentialed candidates at top-of-market compensation while passing over strong engineers. Drawing on Billy Beane&amp;rsquo;s &lt;em&gt;Moneyball&lt;/em&gt; strategy in baseball, Luu argues that organizations should look for engineers who are undervalued by the market yet deliver strong results—an idea widely discussed in theory but rarely practiced. His prescription includes Moneyball-style hiring, investing seriously in onboarding and mentorship, and building better internal tools and processes so engineers can succeed regardless of pedigree. A worthwhile read for both hiring managers and job seekers.&lt;/p&gt;
&lt;h2 id="how-i-solved-a-distributed-queue-problem-after-15-years"&gt;&lt;a href="https://www.dbos.dev/blog/durable-queues" rel="noopener noreferrer"&gt;How I solved a distributed queue problem after 15 years&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jeremy Edberg, formerly in charge of infrastructure at Reddit, revisits a problem that haunted him for years: Reddit relied on distributed RabbitMQ task queues to process almost every user action—such as upvotes—before writing to the database. The architecture scaled well but had a painful flaw: if a worker process crashed after dequeuing a message but before finishing execution, that task was lost forever, taking votes, comments, or posts with it. (While RabbitMQ does support manual acknowledgments to redeliver unacknowledged messages, applications still have to handle side effects and idempotency themselves.)&lt;/p&gt;
&lt;p&gt;The solution he found at DBOS is a durable queue, which combines a task queue with durable workflow execution to reliably orchestrate parallel tasks. Instead of using an in-memory broker like Redis, it uses a persistent relational database—typically PostgreSQL—as both the message broker and the state store. Every task is recorded alongside its inputs, and child tasks are tracked as children of their parent workflow, so after a crash the system resumes from the last completed step rather than starting over. This design also makes it straightforward to enforce concurrency limits, respect third-party API rate limits, and query the full execution history with standard SQL for monitoring and debugging. The main trade-off is raw throughput: Redis-backed queues handle higher message volume, while durable queues shine for lower-volume, high-value business workflows where losing a task is unacceptable.&lt;/p&gt;
&lt;h2 id="cognitive-load-is-what-matters"&gt;&lt;a href="https://minds.md/zakirullin/cognitive" rel="noopener noreferrer"&gt;Cognitive load is what matters&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Artem Zakirullin argues that beneath all the industry buzzwords and &amp;ldquo;best practices,&amp;rdquo; what truly matters in software design is cognitive load: the amount of mental effort a developer must expend to understand and modify code. Human working memory can hold only about four chunks of information at once—such as variable values, control-flow branches, or call-stack hops; cross that threshold and comprehension drops sharply. Intrinsic cognitive load comes from the inherent difficulty of the domain and cannot be removed, whereas extraneous cognitive load is self-inflicted by how the code is structured and can be drastically reduced.&lt;/p&gt;
&lt;p&gt;Examples of extraneous load include deeply nested &lt;code&gt;if&lt;/code&gt; statements (better replaced with well-named intermediate variables or early returns), deep inheritance hierarchies, proliferating shallow modules whose complex interfaces outweigh their tiny implementations, microservices split so finely they become a &amp;ldquo;distributed monolith,&amp;rdquo; overzealous DRY abstractions that couple unrelated domains (&amp;ldquo;a little copying is better than a little dependency&amp;rdquo;), heavy reliance on framework &amp;ldquo;magic,&amp;rdquo; and multi-layered architectures that force readers to trace through half a dozen indirections. Even numeric HTTP status codes force readers to do mental lookups, whereas self-describing error codes like &lt;code&gt;&amp;quot;jwt_has_expired&amp;quot;&lt;/code&gt; convey intent immediately (supplementing rather than replacing the HTTP status). Prefer deep modules: powerful functionality hidden behind a simple interface, like Unix&amp;rsquo;s five basic I/O system calls. The bottom line is that simplicity beats cleverness: good code is code where a newcomer can understand the system and ship a meaningful change within a few hours.&lt;/p&gt;
&lt;h2 id="claude-code-framework-wars"&gt;&lt;a href="https://shmck.substack.com/p/claude-code-framework-wars" rel="noopener noreferrer"&gt;Claude Code Framework Wars&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shawn argues that developers should stop treating Claude as a chat box and start wrapping it in a structured framework: let Claude handle code generation while humans move up the stack to project management, system design, and architecture. Real leverage comes not from clever ad-hoc prompts, but from explicit rules, workflows, and curated context.&lt;/p&gt;
&lt;p&gt;The article maps out eight design decisions involved in building a Claude Code workflow: where work items live (markdown backlogs, structured specs, or issue trackers); how to steer the model via command libraries, coding standards, and verification hooks; how to orchestrate multiple specialized agents; how to run parallel sessions safely using Git worktrees or containers; how to connect Claude to databases, test runners, and external services via MCP; which roles to assign Claude (PM, architect, implementer, QA); the granularity of handoffs, from small pull requests to full application scaffolds; and how to preserve long-term project memory in documentation. It also surveys notable open-source frameworks in this space, including Agent OS, Backlog.md, Claude-Flow, Symphony, Roo Commander, and Claudable. The takeaway is that AI performs best inside rigid guardrails; these frameworks are converging on a future where AI is less a magic black box and more a team of junior developers you manage—and the more structure you invest up front, the better the results.&lt;/p&gt;
&lt;h2 id="the-last-programmers"&gt;&lt;a href="https://www.xipu.li/posts/the-last-programmers" rel="noopener noreferrer"&gt;The Last Programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Xipu Li suggests that we may be the last generation of programmers who manually translate ideas into source code line by line. He left the Amazon Q Developer team in May to join the startup Icon, frustrated by Amazon&amp;rsquo;s slow pace, lack of product vision, and obsession with internal metrics over user experience. At Icon, one of his coworkers barely touches source code at all: he writes plain-English design docs, spins up Claude Code across multiple terminal windows in parallel, and spends most of his day reviewing the output. Inside the team, two camps have emerged: the experimenters who constantly push to eliminate manual coding with AI tools, and the &amp;ldquo;gatekeepers&amp;rdquo; who insist that deep code-level understanding remains non-negotiable. The gatekeepers still catch real AI bugs today, the author notes, but the technology is improving faster than their gatekeeping can keep up.&lt;/p&gt;
&lt;p&gt;He compares software to chocolate: once manufacturing becomes standardized and commoditized, anyone can make chocolate, and competition shifts to branding, distribution, and consumer psychology. As technical implementation becomes a commodity, the three things that retain lasting value are understanding real human needs through behavior rather than surveys, having the taste to know what to build and what not to build, and distribution—getting the product into the right hands. Newcomers should still learn how to program, he advises, but shouldn&amp;rsquo;t treat coding as their only skill. What has always mattered most is understanding people, building what they actually want, and getting it to them; everything else is just an implementation detail.&lt;/p&gt;
&lt;h2 id="bonus-cool-diagrams-from-bytebytego"&gt;Bonus: Cool diagrams from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c8da4839-d519-43a9-bffb-2c81a2c153f4_2250x2624.png" alt="A Guide to Rate Limiting Strategies"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/94510aef-adee-4c78-84cf-05dfe5f9d6c0_3000x3900.png" alt="9 Docker Best Practices You Should Know"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a5e59510-28d9-423e-bdc4-986d24e58f91_2808x4096.jpeg" alt="Where Do We Cache Data?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos"&gt;Bonus: Interesting videos&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=X0-TGhktFnE" rel="noopener noreferrer"&gt;All New Java Language Features Since Java 21 #RoadTo25&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #31</title><link>https://miti99.com/en/post/2025/05/18/</link><pubDate>Sun, 18 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/18/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="optimizing-our-e2e-pipeline"&gt;&lt;a href="https://slack.engineering/speedup-e2e-testing/" rel="noopener noreferrer"&gt;Optimizing Our E2E Pipeline&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s DevXP team shares how they optimized the end-to-end (E2E) test pipeline for the company&amp;rsquo;s largest monorepo. Previously, each run took about 10 minutes, with nearly half of that spent building the frontend—even when a change didn&amp;rsquo;t touch frontend code at all. With hundreds of pull requests merged daily, that produced thousands of builds per week, each taking nearly 1 GB on AWS S3 and adding up to terabytes of duplicate artifacts.&lt;/p&gt;
&lt;p&gt;Their solution used tools they already had: run &lt;code&gt;git diff&lt;/code&gt; with three-dot syntax to compare the current branch against its merge-base with &lt;code&gt;main&lt;/code&gt;; if no frontend files changed, skip the build step and reuse a recent production build served through an internal CDN. Even in a repository with over 100,000 files, detecting changes and locating a matching build takes under 3 seconds. As a result, total builds dropped by 60%, saving hundreds of compute hours per month and several terabytes of storage, while average build time fell from about 5 minutes to 2 minutes (and combined with an earlier Webpack upgrade, from 10 minutes down to 2 minutes overall). As an unexpected bonus, tests also became more stable and less flaky. The takeaway: regularly question which pipeline steps are actually necessary, even in systems that aren&amp;rsquo;t visibly broken.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="doordash"&gt;&lt;a href="https://careersatdoordash.com/blog/doordash-fast-travel-estimates/" rel="noopener noreferrer"&gt;DoorDash&amp;rsquo;s Fast Travel Estimates&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DoorDash engineers explain how they estimate travel distance and duration in milliseconds—a core input for finding nearby stores, predicting delivery ETAs, calculating fees, and matching dashers. Calling a routing engine like OSRM directly typically takes over 100 ms, which is too slow for latency-sensitive paths like homepage refreshes or search ranking, while straight-line (haversine) distance is fast but inaccurate because it ignores real road networks.&lt;/p&gt;
&lt;p&gt;Their answer is Geo-Grid-Cache: partition the entire service area into hexagonal cells using the H3 spatial index, then precompute travel times between cell centers with OSRM under average traffic conditions. Each pair is stored across three resolution tiers—fine for trips under a mile, medium, and coarse for distances up to 100 miles—balancing cache hit rate, storage cost, and accuracy. At request time, the system looks up the pair in a Redis cluster and picks the highest resolution available. The hardest part was generating offline data for roughly 6 billion cell pairs; the team ran Spark on Databricks and installed OSRM directly on the cluster nodes to replace network calls with local HTTP calls, speeding up generation by 10x. The result is ultra-low latency, accuracy close to the internal routing engine, and major compute savings.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="tech-hiring-is-this-an-inflection-point"&gt;&lt;a href="https://blog.pragmaticengineer.com/tech-hiring-is-this-an-inflection-point/" rel="noopener noreferrer"&gt;Tech Hiring: Is This an Inflection Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (The Pragmatic Engineer) highlights a paradox: even though fewer companies are hiring and more candidates are competing for roles, many engineering managers say 2025 is the hardest hiring market they have ever seen. A telling case is maestro.dev, a fully remote startup: every LinkedIn job posting draws hundreds of mostly unqualified applications, cover letters are almost universally AI-generated, and many candidates read answers straight from AI tools during live coding interviews. When the team switched to a take-home assignment, the head of engineering embedded a hidden prompt instruction aimed at AI assistants inside the spec—all four submissions followed the hidden instruction, even though three of the candidates insisted they hadn&amp;rsquo;t used AI. The most reliable signal came instead from candidates who reached out directly to explain why they wanted to join.&lt;/p&gt;
&lt;p&gt;Another remote company had to fire a senior data engineer after just two weeks upon discovering the person had fabricated their experience and used multiple AI tools simultaneously to pass the interview loop. That company is now considering adding a final in-person interview round despite the $1,500–$2,000 cost per candidate, while leaning harder on referrals since 4 of its last 5 hires came through internal recommendations. The post also covers LinkedIn Recruiter costs of $5,000–$20,000 per seat per month, the rise of paid &amp;ldquo;work trial&amp;rdquo; weeks, and the need to redesign remote hiring from the ground up in the AI era.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="underusing-snapshot-testing"&gt;&lt;a href="https://matklad.github.io/2025/04/15/underusing-snapshot-testing.html" rel="noopener noreferrer"&gt;Underusing Snapshot Testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aleksey Kladov (matklad), creator of rust-analyzer, explains why he thinks he still underuses snapshot testing. The idea is straightforward: serialize a test&amp;rsquo;s output into text, compare it against an expected string literal embedded right in the source file, and use a tool to automatically update that literal from the actual output. The obvious benefit is easy maintenance when requirements change: the tool rewrites the expected output so the author can review the diff instead of editing strings by hand.&lt;/p&gt;
&lt;p&gt;What surprised him came from implementing permutation encoding in Zig—a problem whose requirements never change. With traditional assertion-based tests, execution stops at the first failure and the output is buried in a terminal window far from the code. Switching to inline snapshots surfaced every wrong result right inside the source file, letting him see the full picture at once and quickly spot two off-by-one bugs. In his view, snapshot tests keep data close to the programmer, tighten the feedback loop, and act like a repeatable REPL, speeding up development even when requirements are fixed. The end of the post also explains why a handful of concrete examples remain valuable alongside exhaustive testing over all permutations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="principles-for-coding-securely-with-llms"&gt;&lt;a href="https://www.seangoedecke.com/ai-security/" rel="noopener noreferrer"&gt;Principles for coding securely with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that LLM security shouldn&amp;rsquo;t be treated as a long checklist of disconnected threats, but derived from a single principle: LLMs sometimes act maliciously, so treat their output like untrusted user input. Prompt injection is fundamentally unavoidable—the moment you bring third-party content (web pages, docs, Cursor rules files) into the context window, you give its author a chance to steer the model, and no model is immune to jailbreaks.&lt;/p&gt;
&lt;p&gt;From that principle, every tool an LLM is allowed to call should be scoped and authorized like a public user-facing API: for example, expose &lt;code&gt;fetch_messages()&lt;/code&gt; rather than &lt;code&gt;fetch_messages(user_id)&lt;/code&gt; so the model cannot read another user&amp;rsquo;s messages, and require explicit human confirmation for high-impact actions like sending messages or transferring money. MCP servers are effectively remote libraries, meaning you are trusting the server&amp;rsquo;s owner, not just its interface. Even without an attacker, LLMs can hallucinate or take reckless actions, so human approval gates must be enforced in tool code rather than requested in the prompt. Goedecke also notes risks from fine-tuned or self-trained models (goal misalignment or leaking sensitive training data) and denial-of-service (DoS) attacks, since LLM calls are slow and GPU-heavy—cap concurrent sessions, token budgets, and tool access accordingly.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-i-don"&gt;&lt;a href="https://www.gleech.org/llms" rel="noopener noreferrer"&gt;How I don&amp;rsquo;t use LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin Leech, an AI PhD, candidly explains why he rarely uses LLMs for intellectual work despite knowing firsthand how capable they are. Every time a new frontier model comes out, he tries it, and every time it confidently makes a serious error within the first few minutes. His reasons include loving writing enough that editing weak prose takes more effort than drafting from scratch, already having solid foundational knowledge across many fields, needing high accuracy and reliability when learning, disliking the model&amp;rsquo;s voice and habit of bluffing, worrying about skill atrophy, and not writing much code at the time.&lt;/p&gt;
&lt;p&gt;Even so, he still uses LLMs in specific situations: as a search replacement (only when citations are provided), for tip-of-the-tongue term recall, finding entry-point keywords in an unfamiliar field, semantic search over document collections, validating and converting JSON to CSV, getting past blank-page syndrome, and especially writing Matplotlib code or untangling Docker, WSL, and Cloudflare issues. To bypass model sycophancy, he frames his own ideas as if they came from someone else. The post strikes a balanced, self-critical tone: Leech admits part of the problem may be his own impatience, while warning that LLMs can quietly plant a few plausible falsehoods in your head every day.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-senior-software-engineers-can-learn-from-junior-engineers"&gt;&lt;a href="https://www.infoq.com/news/2025/04/software-engineers-learning/" rel="noopener noreferrer"&gt;How Senior Software Engineers Can Learn from Junior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This InfoQ piece summarizes Beth Anderson&amp;rsquo;s QCon London talk on what senior engineers can learn from junior teammates. She notes that steep power distances on a team make junior engineers hesitant to speak up even when they spot a problem with serious consequences, stifling innovation and collaboration. Rather than treating mentorship as a one-way street, senior engineers should recognize that junior colleagues often bring high energy, fresh perspectives, and up-to-date skills.&lt;/p&gt;
&lt;p&gt;To build an inclusive culture, Anderson recommends active listening, amplifying others&amp;rsquo; voices, crediting contributions, and creating the psychological safety needed for juniors to ask questions freely. One concrete practice is &amp;ldquo;reverse feedback&amp;rdquo;: asking junior engineers to critique how seniors communicate with them, asking how they prefer to learn, and inviting them to review senior engineers&amp;rsquo; code and pull requests as a learning exercise. She also urges juniors not to repeat the dismissive behaviors that once frustrated them when they become seniors themselves, because seniority is not about authority—it is an opportunity to create positive change. Every engineer, at every level, has a perspective worth learning from if we are willing to listen.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="as-an-engineer-i"&gt;&lt;a href="https://shiftmag.dev/asking-questions-engineering-career-advice-4895/" rel="noopener noreferrer"&gt;As an engineer, I&amp;rsquo;d rather be called stupid than stay silent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marko Antanaskovic recounts overcoming imposter syndrome while working as a Customer Support Engineer at Infobip. Opening with a fictional incident call packed with impenetrable jargon, he captures a familiar feeling: not understanding what the developers are saying, yet staying quiet out of fear of looking stupid while the customer waits for an update. Realizing nobody could know everything across such a massive platform—and that no textbook covered it—he decided to tap the knowledge of his colleagues by asking &amp;ldquo;stupid&amp;rdquo; questions like &amp;ldquo;What does that actually mean?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Antanaskovic points out the real cost of silence: prolonged outages because nobody connects the technical symptom to customer impact, poor work caused by misunderstood requirements, and meetings that sink into awkward silence. To build a questioning culture, he suggests being the first to ask, shifting from blame to education in the spirit of a blameless culture, and trusting the people around you. That willingness to look &amp;ldquo;stupid&amp;rdquo; helped him build enough deep system knowledge to transition into a Reliability Operations Engineer role. His closing takeaway: no sincere question is stupid, and it is far better to risk looking foolish than to stay silent and make preventable mistakes.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>