<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Go From Scratch on Atharva Pandey</title><link>https://atharva.page/series/go-from-scratch/</link><description>Recent content in Go From Scratch on Atharva Pandey</description><generator>Hugo</generator><language>en-us</language><copyright>Copyright ©</copyright><lastBuildDate>Sat, 11 May 2024 00:00:00 +0000</lastBuildDate><atom:link href="https://atharva.page/series/go-from-scratch/index.xml" rel="self" type="application/rss+xml"/><item><title>Lesson 25: What's Next — Your roadmap from beginner to production Go</title><link>https://atharva.page/post/go/go-scratch-whats-next/</link><pubDate>Sat, 11 May 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-whats-next/</guid><description>&lt;p&gt;You made it. Twenty-five lessons ago you didn&amp;rsquo;t know what &lt;code&gt;package main&lt;/code&gt; meant. Now you understand variables, types, functions, error handling, interfaces, goroutines, testing, JSON, file I/O, the type system, and the entire toolchain. That is not beginner knowledge anymore.&lt;/p&gt;
&lt;p&gt;But there&amp;rsquo;s a gap between knowing the language and writing Go the way experienced Go developers write it. This lesson is about that gap — what it is, how to close it, and what to build while you do.&lt;/p&gt;</description></item><item><title>Lesson 24: The Go Toolchain — build, test, vet, fmt — your daily tools</title><link>https://atharva.page/post/go/go-scratch-toolchain/</link><pubDate>Tue, 07 May 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-toolchain/</guid><description>&lt;p&gt;One of the things that drew me to Go was that the toolchain ships with the language. You don&amp;rsquo;t need to choose a build tool, a formatter, or a test framework — they&amp;rsquo;re all there from day one, and they&amp;rsquo;re all invoked the same way: &lt;code&gt;go &amp;lt;command&amp;gt;&lt;/code&gt;. This lesson is a tour of the tools you&amp;rsquo;ll use every single day.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-basics"&gt;The Basics&lt;/h2&gt;
&lt;h3 id="go-run-and-go-build"&gt;go run and go build&lt;/h3&gt;
&lt;p&gt;You&amp;rsquo;ve used &lt;code&gt;go run&lt;/code&gt; throughout this course. It compiles your code and immediately executes it — perfect for development. Under the hood it creates a temporary binary and runs it, then throws the binary away.&lt;/p&gt;</description></item><item><title>Lesson 23: The Type System — Types, aliases, conversions, and embedding</title><link>https://atharva.page/post/go/go-scratch-type-system/</link><pubDate>Thu, 02 May 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-type-system/</guid><description>&lt;p&gt;When I first came to Go from Python, the type system felt like a lot of ceremony. Why can&amp;rsquo;t I just use an &lt;code&gt;int&lt;/code&gt; where a &lt;code&gt;float64&lt;/code&gt; is expected? Why do I need to define a whole new type just to give an integer more meaning? The answers to those questions turned out to be one of the things I now appreciate most about Go. Types aren&amp;rsquo;t bureaucracy — they&amp;rsquo;re a way of making your code explain itself.&lt;/p&gt;</description></item><item><title>Lesson 22: File I/O — Reading and writing files the Go way</title><link>https://atharva.page/post/go/go-scratch-files/</link><pubDate>Fri, 26 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-files/</guid><description>&lt;p&gt;At some point every program needs to persist something — a config file, a log, a data export. File I/O is one of those topics that sounds tedious but is genuinely satisfying once it clicks. Go gives you a few different layers to work with, from the low-level &lt;code&gt;os&lt;/code&gt; package to convenient one-liners. I&amp;rsquo;ll show you all of them so you can pick the right tool for the job.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-basics"&gt;The Basics&lt;/h2&gt;
&lt;h3 id="reading-a-file-the-simple-way"&gt;Reading a file the simple way&lt;/h3&gt;
&lt;p&gt;For most cases where the file is small enough to fit in memory, &lt;code&gt;os.ReadFile&lt;/code&gt; is all you need:&lt;/p&gt;</description></item><item><title>Lesson 21: JSON and HTTP — Reading and writing the web's language</title><link>https://atharva.page/post/go/go-scratch-json/</link><pubDate>Sun, 21 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-json/</guid><description>&lt;p&gt;Almost every program I write these days talks to something over HTTP — a third-party API, a database service, a webhook. And almost everything speaks JSON. So learning how Go handles JSON and HTTP isn&amp;rsquo;t an advanced topic; it&amp;rsquo;s one of the most practical skills you can pick up early.&lt;/p&gt;
&lt;p&gt;In this lesson I&amp;rsquo;ll walk you through converting Go structs to JSON and back, decoding JSON from an API response, and making real HTTP requests — all using only Go&amp;rsquo;s standard library. No third-party packages needed.&lt;/p&gt;</description></item><item><title>Lesson 20: Testing in Go — Every Go file gets a test file</title><link>https://atharva.page/post/go/go-scratch-testing/</link><pubDate>Wed, 17 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-testing/</guid><description>&lt;p&gt;I used to think testing was something you did after you finished writing code — a checkbox you ticked before committing. Go changed that attitude for me, not by lecturing me about best practices, but by making testing so straightforward that there was no excuse not to do it. The tooling is built in, the conventions are clear, and writing a test in Go takes about as long as writing the function itself. After a few weeks with Go, I started writing tests alongside my code, then slightly before it. The feedback loop became addictive.&lt;/p&gt;</description></item><item><title>Lesson 19: Context — Passing deadlines and cancellation through your code</title><link>https://atharva.page/post/go/go-scratch-context/</link><pubDate>Fri, 12 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-context/</guid><description>&lt;p&gt;There&amp;rsquo;s a moment in every Go developer&amp;rsquo;s journey when they realize that starting an operation isn&amp;rsquo;t the hard part — stopping it cleanly is. What happens when a user cancels a request? What happens when a database query takes 30 seconds instead of 300 milliseconds? Without a way to communicate &amp;ldquo;stop what you&amp;rsquo;re doing,&amp;rdquo; those goroutines keep running, consuming resources for something that no longer matters.&lt;/p&gt;
&lt;p&gt;That&amp;rsquo;s the problem &lt;code&gt;context&lt;/code&gt; solves. It gives you a standard way to carry a cancellation signal, a deadline, and a small amount of request-scoped data through your entire call stack. Once you understand it, you&amp;rsquo;ll see why the Go standard library passes it as the first parameter to almost every function that does I/O.&lt;/p&gt;</description></item><item><title>Lesson 18: The sync Package — Coordination tools for concurrent code</title><link>https://atharva.page/post/go/go-scratch-sync/</link><pubDate>Sat, 06 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-sync/</guid><description>&lt;p&gt;Goroutines make concurrency easy to start, but easy to start isn&amp;rsquo;t the same as easy to get right. The first time I ran multiple goroutines that touched shared data, I got a data race — a situation where two goroutines read and write the same variable at the same time, producing unpredictable results. The Go race detector caught it immediately, but I still had to understand &lt;em&gt;how to fix it&lt;/em&gt;.&lt;/p&gt;</description></item><item><title>Lesson 17: Go Modules — Managing dependencies without pain</title><link>https://atharva.page/post/go/go-scratch-modules/</link><pubDate>Tue, 02 Apr 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-modules/</guid><description>&lt;p&gt;Before Go modules existed, managing dependencies was genuinely painful. People used all sorts of third-party tools with their own conventions, and getting a new contributor up and running on a project could eat half a day. I started learning Go after modules became the standard, and I took for granted how smooth the experience was — until I read the old blog posts describing what came before. It made me appreciate &lt;code&gt;go mod init&lt;/code&gt; in a way that&amp;rsquo;s hard to describe.&lt;/p&gt;</description></item><item><title>Lesson 16: Packages and Imports — Organizing code like a professional</title><link>https://atharva.page/post/go/go-scratch-packages/</link><pubDate>Wed, 27 Mar 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-packages/</guid><description>&lt;p&gt;Every Go program I&amp;rsquo;ve written has taught me the same lesson over and over: good code isn&amp;rsquo;t just about what you write inside functions — it&amp;rsquo;s about how you organize those functions in the first place. When I started with Go, I crammed everything into one file. It worked, until it didn&amp;rsquo;t. By the time I had a few hundred lines, I couldn&amp;rsquo;t find anything. That&amp;rsquo;s when packages stopped being an abstract concept and became something I genuinely needed.&lt;/p&gt;</description></item><item><title>Lesson 15: Select — Waiting on multiple channels at once</title><link>https://atharva.page/post/go/go-scratch-select/</link><pubDate>Fri, 22 Mar 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-select/</guid><description>&lt;p&gt;By now you know how to create goroutines and how to communicate between them using channels. But what happens when a goroutine needs to listen to two channels at the same time? Maybe it&amp;rsquo;s waiting for work to arrive, but it also needs to stop if a timeout fires. With a single channel you&amp;rsquo;d be stuck — receiving from one blocks the other.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;select&lt;/code&gt; solves this. It&amp;rsquo;s like a &lt;code&gt;switch&lt;/code&gt; statement for channels. It waits until one of several channel operations is ready, then executes that case. If multiple are ready at the same time, it picks one at random.&lt;/p&gt;</description></item><item><title>Lesson 14: Channels — How goroutines talk to each other</title><link>https://atharva.page/post/go/go-scratch-channels/</link><pubDate>Mon, 18 Mar 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-channels/</guid><description>&lt;p&gt;In the last lesson, I showed you how to run code concurrently with goroutines. But goroutines that can&amp;rsquo;t talk to each other aren&amp;rsquo;t very useful. What if one goroutine produces a result that another needs? What if you want to signal that work is done without using a &lt;code&gt;WaitGroup&lt;/code&gt;? That&amp;rsquo;s where channels come in.&lt;/p&gt;
&lt;p&gt;Go&amp;rsquo;s guiding philosophy on concurrency is: &amp;ldquo;don&amp;rsquo;t communicate by sharing memory; share memory by communicating.&amp;rdquo; Channels are the mechanism for that. Instead of multiple goroutines reading and writing the same variable, they pass values through a channel — and the channel ensures only one goroutine handles the value at a time.&lt;/p&gt;</description></item><item><title>Lesson 13: Goroutines — Lightweight threads that cost almost nothing</title><link>https://atharva.page/post/go/go-scratch-goroutines/</link><pubDate>Tue, 12 Mar 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-goroutines/</guid><description>&lt;p&gt;One of the first things people told me about Go was &amp;ldquo;it makes concurrency easy.&amp;rdquo; I was sceptical — concurrency is never easy. But the more I used goroutines, the more I understood what they meant. It&amp;rsquo;s not that concurrency becomes simple. It&amp;rsquo;s that the cost of starting a concurrent task drops so low that you stop avoiding it.&lt;/p&gt;
&lt;p&gt;In most languages, spawning a thread involves megabytes of stack memory and significant overhead. A Go goroutine starts with about 2KB of stack. You can run tens of thousands of them on a normal laptop without breaking a sweat.&lt;/p&gt;</description></item><item><title>Lesson 12: Error Handling — Errors are values, not exceptions</title><link>https://atharva.page/post/go/go-scratch-errors/</link><pubDate>Wed, 06 Mar 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-errors/</guid><description>&lt;p&gt;The first time I wrote Go after years of Python and JavaScript, I kept waiting for the &lt;code&gt;try/catch&lt;/code&gt; block. It never came. Instead, almost every function returned two values: the result, and an error. I had to check the error every single time. It felt tedious at first. After a few weeks, I realised it was one of the best design decisions in the language.&lt;/p&gt;
&lt;p&gt;In Go, errors are just values. They&amp;rsquo;re not special. They don&amp;rsquo;t teleport up the call stack. They sit right there, in your return value, waiting for you to deal with them.&lt;/p&gt;</description></item><item><title>Lesson 11: Interfaces — Contracts without the paperwork</title><link>https://atharva.page/post/go/go-scratch-interfaces/</link><pubDate>Sat, 24 Feb 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-interfaces/</guid><description>&lt;p&gt;When I first learned about interfaces in Go, I expected something complicated — annotations, &lt;code&gt;implements&lt;/code&gt; keywords, class hierarchies. Instead, Go just asked: &amp;ldquo;does your type have the right methods?&amp;rdquo; That&amp;rsquo;s it. No paperwork. No explicit declaration. If your type does what the interface requires, it satisfies the interface automatically.&lt;/p&gt;
&lt;p&gt;This sounds small, but it changes how you design programs entirely.&lt;/p&gt;
&lt;h2 id="the-basics"&gt;The Basics&lt;/h2&gt;
&lt;p&gt;An interface in Go is a named set of method signatures. Any type that implements those methods automatically satisfies the interface. You don&amp;rsquo;t declare that you&amp;rsquo;re satisfying it. Go figures it out at compile time.&lt;/p&gt;</description></item><item><title>Lesson 10: Pointers — Addresses, not magic</title><link>https://atharva.page/post/go/go-scratch-pointers/</link><pubDate>Sat, 17 Feb 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-pointers/</guid><description>&lt;p&gt;Pointers have a reputation for being scary. In C, they&amp;rsquo;re the source of buffer overflows, dangling references, and cryptic crashes. In Go, pointers are much tamer. There&amp;rsquo;s no pointer arithmetic, the garbage collector handles memory for you, and the rules are simpler. But pointers are still important — without them, you can&amp;rsquo;t write Go programs that mutate data through function calls, and you can&amp;rsquo;t use pointer receivers (which we covered in the last lesson).&lt;/p&gt;</description></item><item><title>Lesson 9: Methods — Functions that belong to a type</title><link>https://atharva.page/post/go/go-scratch-methods/</link><pubDate>Sun, 11 Feb 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-methods/</guid><description>&lt;p&gt;In the last lesson we defined a &lt;code&gt;User&lt;/code&gt; struct. We could pass it to functions — &lt;code&gt;birthday(u)&lt;/code&gt;, &lt;code&gt;sendEmail(u)&lt;/code&gt;, &lt;code&gt;formatName(u)&lt;/code&gt;. That works, but there&amp;rsquo;s a better way: we can attach functions directly to the &lt;code&gt;User&lt;/code&gt; type. Then instead of &lt;code&gt;birthday(u)&lt;/code&gt; we write &lt;code&gt;u.Birthday()&lt;/code&gt;. Those are called methods.&lt;/p&gt;
&lt;p&gt;Methods make code more readable, more organized, and closer to how we naturally think about objects — &amp;ldquo;a user does birthday-related things&amp;rdquo; rather than &amp;ldquo;a birthday function takes a user.&amp;rdquo;&lt;/p&gt;</description></item><item><title>Lesson 8: Structs — Your first custom type</title><link>https://atharva.page/post/go/go-scratch-structs/</link><pubDate>Wed, 07 Feb 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-structs/</guid><description>&lt;p&gt;So far we&amp;rsquo;ve been working with Go&amp;rsquo;s built-in types: strings, ints, booleans, slices, maps. Those are great, but real programs deal with real-world things — users, orders, products, messages. You need a way to group related data together and give it a meaningful name. In Go, that&amp;rsquo;s a struct.&lt;/p&gt;
&lt;p&gt;If you come from Python, think of a struct as a lightweight class that holds data (but with no inheritance, and methods are defined separately). If you come from JavaScript, think of it as a typed object. If you come from C, structs work almost exactly the same way.&lt;/p&gt;</description></item><item><title>Lesson 7: Strings, Runes, and Bytes — Strings aren't what you think</title><link>https://atharva.page/post/go/go-scratch-strings/</link><pubDate>Fri, 02 Feb 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-strings/</guid><description>&lt;p&gt;Strings look simple. You write &lt;code&gt;&amp;quot;hello&amp;quot;&lt;/code&gt;, you print it, done. But when I first started working with non-ASCII text in Go — names with accents, emoji, Chinese characters — things started behaving oddly. &lt;code&gt;len(&amp;quot;café&amp;quot;)&lt;/code&gt; returned 5, not 4. Iterating with a regular index loop gave me garbled output. It took me a while to understand why, and once I did, a lot of things clicked.&lt;/p&gt;
&lt;p&gt;The short version: Go strings are sequences of bytes, not characters. Once you internalize that, the rest makes sense.&lt;/p&gt;</description></item><item><title>Lesson 6: Maps — Key-value pairs that power everything</title><link>https://atharva.page/post/go/go-scratch-maps/</link><pubDate>Sat, 27 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-maps/</guid><description>&lt;p&gt;Every language has some version of the dictionary or hash map. Python calls it a &lt;code&gt;dict&lt;/code&gt;, JavaScript calls it an &lt;code&gt;Object&lt;/code&gt; or &lt;code&gt;Map&lt;/code&gt;, Ruby calls it a &lt;code&gt;Hash&lt;/code&gt;. In Go, it&amp;rsquo;s just called a map. Once you understand how Go maps work, you&amp;rsquo;ll reach for them constantly — they&amp;rsquo;re one of the most useful data structures in the language.&lt;/p&gt;
&lt;h2 id="the-basics"&gt;The Basics&lt;/h2&gt;
&lt;h3 id="creating-a-map"&gt;Creating a map&lt;/h3&gt;
&lt;p&gt;The zero value of a map is &lt;code&gt;nil&lt;/code&gt;. A nil map is readable (it returns zero values) but not writable. If you try to write to a nil map, your program panics. The safe way to create a map is with &lt;code&gt;make&lt;/code&gt;:&lt;/p&gt;</description></item><item><title>Lesson 5: Arrays and Slices — Slices are what you actually use</title><link>https://atharva.page/post/go/go-scratch-arrays-slices/</link><pubDate>Mon, 22 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-arrays-slices/</guid><description>&lt;p&gt;Go has two sequence types: arrays and slices. I&amp;rsquo;ll tell you upfront — arrays are rarely used directly. They exist, they matter for understanding how things work under the hood, but in day-to-day Go programming you&amp;rsquo;ll almost always reach for a slice instead.&lt;/p&gt;
&lt;p&gt;Slices are Go&amp;rsquo;s workhorse collection type. They&amp;rsquo;re flexible, they grow when you need them to, and they&amp;rsquo;re used everywhere: in standard library APIs, in function parameters, in HTTP handlers. Understanding slices well will make you a much more effective Go programmer than memorizing syntax ever will.&lt;/p&gt;</description></item><item><title>Lesson 4: Functions — Small functions are Go's building blocks</title><link>https://atharva.page/post/go/go-scratch-functions/</link><pubDate>Wed, 17 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-functions/</guid><description>&lt;p&gt;If there&amp;rsquo;s one thing experienced Go programmers agree on, it&amp;rsquo;s this: write small functions. Not tiny, cryptic one-liners, but focused functions that do one thing and are easy to test. Go&amp;rsquo;s function syntax encourages this style — it&amp;rsquo;s clean, explicit, and has one feature that&amp;rsquo;s genuinely different from most languages you&amp;rsquo;ve used before: multiple return values.&lt;/p&gt;
&lt;p&gt;In Python you can return a tuple. In JavaScript you can return an array. But in Go, returning two or three values is a first-class language feature with its own syntax, and it fundamentally changes how error handling works. By the end of this lesson you&amp;rsquo;ll understand Go functions well enough to start writing real, useful programs.&lt;/p&gt;</description></item><item><title>Lesson 3: Control Flow — if, for, and switch are all you need</title><link>https://atharva.page/post/go/go-scratch-control-flow/</link><pubDate>Fri, 12 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-control-flow/</guid><description>&lt;p&gt;Every program you&amp;rsquo;ll ever write needs to make decisions and repeat actions. &amp;ldquo;If this condition is true, do that. Otherwise, do something else.&amp;rdquo; &amp;ldquo;Keep doing this until we run out of items.&amp;rdquo; These are the fundamental building blocks of logic, and Go handles them with just three constructs: &lt;code&gt;if&lt;/code&gt;, &lt;code&gt;for&lt;/code&gt;, and &lt;code&gt;switch&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;That&amp;rsquo;s it. No &lt;code&gt;while&lt;/code&gt;. No &lt;code&gt;do-while&lt;/code&gt;. No &lt;code&gt;foreach&lt;/code&gt; as a separate keyword. Go&amp;rsquo;s designers made a deliberate choice to keep the language small — fewer constructs means fewer ways to do the same thing, which means code is more consistent and easier to read across different projects and teams.&lt;/p&gt;</description></item><item><title>Lesson 2: Variables and Types — Go is typed, and that's a good thing</title><link>https://atharva.page/post/go/go-scratch-variables-types/</link><pubDate>Mon, 08 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-variables-types/</guid><description>&lt;p&gt;If you&amp;rsquo;re coming from Python or JavaScript, Go&amp;rsquo;s type system might feel like extra work at first. Why should you have to tell the compiler that a variable holds a number? Can&amp;rsquo;t it just figure it out?&lt;/p&gt;
&lt;p&gt;Here&amp;rsquo;s the thing — it usually can. Go has type inference, so you rarely have to write out types explicitly. But when types &lt;em&gt;are&lt;/em&gt; written out, every person reading your code knows exactly what kind of data they&amp;rsquo;re dealing with. There&amp;rsquo;s no guessing, no surprises at runtime because a string snuck in where you expected a number. Go catches those mistakes at compile time, before your code ever runs.&lt;/p&gt;</description></item><item><title>Lesson 1: Your First Go Program — Hello World is just the beginning</title><link>https://atharva.page/post/go/go-scratch-first-program/</link><pubDate>Wed, 03 Jan 2024 00:00:00 +0000</pubDate><guid>https://atharva.page/post/go/go-scratch-first-program/</guid><description>&lt;p&gt;I remember the first time I ran a Go program. The compiler yelled at me for an unused import, and I thought, &amp;ldquo;Okay, this language has opinions.&amp;rdquo; That&amp;rsquo;s not a bad thing. Go&amp;rsquo;s strictness is part of what makes it so readable and maintainable. Once you understand &lt;em&gt;why&lt;/em&gt; Go works the way it does, it starts to feel less like friction and more like clarity.&lt;/p&gt;
&lt;p&gt;In this lesson you&amp;rsquo;re going to write your first Go program, understand every single line of it, and learn the basic tools you&amp;rsquo;ll use every day. By the end, &amp;ldquo;Hello, World!&amp;rdquo; won&amp;rsquo;t feel like a throwaway demo — it&amp;rsquo;ll feel like a foundation.&lt;/p&gt;</description></item></channel></rss>