<?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 Chloe Verity on Medium]]></title>
        <description><![CDATA[Stories by Chloe Verity on Medium]]></description>
        <link>https://medium.com/@chloe-verity?source=rss-8994e6151aa8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*IQpX0HNdJXfB-w1g.jpg</url>
            <title>Stories by Chloe Verity on Medium</title>
            <link>https://medium.com/@chloe-verity?source=rss-8994e6151aa8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 09:07:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chloe-verity/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[iOS App Architecture for Web Developers]]></title>
            <link>https://medium.com/songkick-dev-blog/ios-app-architecture-for-web-developers-c289c191052c?source=rss-8994e6151aa8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c289c191052c</guid>
            <category><![CDATA[view-controller]]></category>
            <category><![CDATA[mvc]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Chloe Verity]]></dc:creator>
            <pubDate>Fri, 16 Oct 2020 13:30:39 GMT</pubDate>
            <atom:updated>2020-10-16T13:30:39.138Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 3: View Controllers</h3><p><em>This article is part of a series of posts dedicated to helping web developers new to mobile development bridge the gap between building web apps and iOS using the common MVC pattern, as told by two developers at Songkick who have recently made the jump themselves.</em></p><p><em>If you haven’t read the previous post, please </em><a href="https://devblog.songkick.com/ios-app-architecture-for-web-developers-f61ded0ef427"><em>click here.</em></a></p><p>If you’ve made it this far, well done!</p><p>There’s only so many times I can introduce what the MVC pattern is using the same diagram — so this time, let’s use an analogy. I want you to think of your favourite meal. Mine is a good ol’ pepperoni pizza. Now, let’s say, for some reason I wanted to make my own pizzas for a pizza party I’m having with my friends; imagine I’ve filled the fridge with all the raw ingredients. We have all the makings and mechanics of a pizza stored away in there: the necessities like dough, tomato sauce, mozzarella, and some other bits and pieces for toppings, that will be used depending on the wants of the person eating it. That’s basically the Model in a nutshell; a data blueprint (of a pizza).</p><p>And if, as we saw from the previous instalment in our series, a View encapsulates all that the user sees and is able to interact with, then at our pizza party, the View is each encapsulation of a pizza that sits before one of my friends; a combination of their choices (toppings) while still abiding by the fundamental architectural rules of the pizza (for example, without dough, it’s not a pizza, and no, we’re not counting cauliflower pizzas). So, then what the hell is a View Controller?</p><p>In this case, the View Controller would be the recipe. The recipe dictates the logic behind how we use the raw materials/data from the Model, and how we turn it into something tangible that the user can see and interact with (the View). It’s flexible (there are many different recipes that give you a pizza), yet if the View Controller isn’t doing it’s job correctly, then the final product isn’t displayed on the screen properly, much like how you could assemble the ingredients in any way, but you might not end up with something that constitutes a pizza.</p><p><strong>So what actually goes in the View Controller?</strong></p><p>View Controllers, considering they are the bridge between the Model and the View, are largely considered to be skewed towards the View; each View Controller (usually) represents one screen of the app, and has one or more corresponding Views to make up that screen.</p><p>As discussed in the View portion of this series, the View Controller contains references to most, if not all, of the objects that appear on the View. This is to handle user input, or so that they can be interacted with; for example, in the View Controller, we can give a button specific instructions on what it needs to do when pressed. We do that like so:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qRnLjrtblO-4HyC0" /><figcaption>Anatomy of a button created programmatically</figcaption></figure><p>In this example, we can see that on loading the View, we first give the viewAllButton several properties, such as colour, title colour and title text. The reasons you might want to set these attributes programmatically are manyfold; you might want to localise the text so it can appear in 15 different languages, you might want to, as shown above, manipulate an attribute depending on the state of the object (as we can see where we set a different title colour for the button depending on whether the button is selected or not), perhaps you want to reuse the object later, perhaps you want to populate text or manipulate the View depending on data from the Model (or maybe you just have a general aversion to interface builder), all are perfectly valid.</p><p>The next thing to do is add a target to the button, which has three parameters: the target, an action, and the control events. The target is the object whose action method is called. The action is the method you want to invoke when the object is interacted with, and the control event is the type of gesture event that launches it (touchUpInside is the most used gesture, for it reflects a simple tap, but there are several that you can invoke this way). Think of this as the Swift version of an event listener.</p><p>And finally, you need to create the method that you want to call. Throwing it back to Models in Section 1, we might need to create, update or delete database information via our Model. Imagine serving your friend a pizza, but lo and behold you’ve forgotten something: you go back to the recipe (View Controller) and realise you’ve forgotten the anchovies, so you go to the fridge (Model) to grab them, use the recipe again to understand that, yes, they’re placed on top of the cheese, and once you’ve executed those instructions, voilà, your friend is served again with a delicious, updated pizza (View).</p><p>It might be apt just to call a method in our View Controller, or, if the View Controller in which this method lives is the child of another, and we need access to the parent controller’s methods and variables, we might need to pass this method call up to the parent via a delegate. Above, I’ve simply printed something, but as I said, this could be anything your heart desires.</p><p><strong>Why MVC?</strong></p><p>MVC is not unique to Swift; if you’ve ever built a Rails project you’ll know that you should have separate folders for each Models, Views, and Controllers, making it easier for you to identify and understand what each individual piece of code does, and where it fits based on that functionality.</p><p>Now, the ideal scenario is where responsibility is pretty equally spread between the Model, View and Controller. The reality is, however, that the View Controller ends up with disproportionately more responsibility than the other sections, since they seem to lend themselves more naturally as the “place to put things”. What I mean by this is that, if something doesn’t immediately appear to fit the bill of “logic” or “design”, then it gets lumped in the View Controller without a second thought, and before we know it we end up with these massive View Controllers.</p><p>This impacts navigability, sure, but you’ll find that actually, if used as intended, MVC structure makes it easier to navigate through and understand what’s going on in the code base, and makes it possible for people to not only make modifications and debug, but for multiple people to do so simultaneously due to the separation of responsibilities.</p><p>For this reason, if your app necessitates structure and relies on performance, MVC is a good contender, if you are working on a single page app, you probably shouldn’t bother. MVVM (Model, View, View Model) is an alternative, which, rather than having a Controller which ensures that the Model and View don’t talk to each other, has a View Model that actually binds the data between the View and the Model, allowing them to directly talk to each other. MVVM would be the choice for a single page app, since it’s simple and allows direct communication and therefore can move quickly and continuously save to databases. Yet, since it relies on binding the data, it consumes a lot more memory, meaning that it would not be the first choice for larger applications, who as we’ve said should probably be using MVC.</p><p>In pizza terms, MVVM would be like me making all my friends’ pizzas relying solely on my memory — that’s fine if they all want the same thing, but if they don’t, I’d be better off having the recipes in front of me. Ultimately, choose the way that’s going to get the pizza on the table, fastest, easiest and leave everyone satisfied.</p><p>Happy p̶i̶z̶z̶a̶ ̶m̶a̶k̶i̶n̶g̶ engineering!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c289c191052c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/songkick-dev-blog/ios-app-architecture-for-web-developers-c289c191052c">iOS App Architecture for Web Developers</a> was originally published in <a href="https://medium.com/songkick-dev-blog">Songkick Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS App Architecture for Web Developers]]></title>
            <link>https://medium.com/songkick-dev-blog/ios-app-architecture-for-web-developers-f61ded0ef427?source=rss-8994e6151aa8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f61ded0ef427</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Chloe Verity]]></dc:creator>
            <pubDate>Thu, 09 Jul 2020 12:51:12 GMT</pubDate>
            <atom:updated>2020-07-09T12:53:04.582Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 2: Views</h3><p><em>This article is part of a series of posts dedicated to helping web developers new to mobile development bridge the gap between building web apps and iOS using the common MVC pattern, as told by three developers at Songkick who have recently made the jump themselves.</em></p><p><em>If you haven’t read the previous post, please </em><a href="https://devblog.songkick.com/ios-app-architecture-for-web-developers-da9d7a132ce9"><em>click here.</em></a></p><p><strong>Views in iOS</strong></p><p>As you will recall from our previous post (by one of our Swift Senseis in residence, Alex) on the Model-View-Controller pattern, Views are the third of the MVC trio that — yep, you guessed it — represents <em>all that we see</em>. It’s the representation of the user interface , the “face” of our app. Views are not where the business logic of the program resides — we’ve seen that in the models — instead, the View illustrates the interface, detecting user interaction and enabling navigation through the app. The interface allows the user to create an action that might send new information or instructions back to the Controller, which will then relay those message(s) to the Model. A View should not speak directly to the model; instead it should communicate to the ViewController that manages it<em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/506/1*aneeATA8SIv06Zy9-AOIRw.png" /><figcaption>The MVC approach; as we saw in the last post</figcaption></figure><p>When a controller has decided <strong><em>what</em></strong> should be presented on the page, it loads the View. The View is likely composed of a set of UIView objects, which then draw their specified contents, which may in turn be other views.</p><p>Views, similarly to HTML elements, can be nested inside each other, where the parent views are a <em>superview</em>, and the children are <em>subviews</em>. Apple provides a base class (UIView) that all other view classes should inherit from. Since these view classes are now subclasses of UIView, they inherit all of its properties and methods; the parent class now becomes the superclass. Also similarly to HTML, this allows for the repurposing of views across the app; whether it be a more basic, built-in view like a UIButton or UILabel, or a more complex, custom view that is created by you for a specific purpose, unique to your app.</p><p><strong>How do I create a View?</strong></p><p>Great question. You have options! In general, your app (depending on its size) will likely use a combination of these options.</p><p><strong>XIB </strong>it!</p><p>One thing unique to Swift is Interface Builder. Where developing on the web can have a slow feedback loop, stopping and starting to check on the results of a small change, IB allows you to fully visualise your app (on any iOS device you want, no less). You can tie components to the edge of a screen, or to parent or sibling views using constraints in autolayout, leading to a great user experience. Changing things like size, colour, text, in the attributes and size inspector, and even managing its connections (i.e. interactions) to a specific event in the View Controller (we’ll talk more about this later) in the connections inspector means that everything is relatively easy to manage — especially for newcomers to both your codebase and Swift in general. It’s also a great way to prevent your codebase from becoming inflated with unnecessary lines of code, and reducing the amount of bugs you might produce in them. Saying this, it’s worth noting that version control in XIBs (and Storyboards too) can get a touch hairy if several developers on your team are working on the same files.</p><p>The<strong> Programmatic</strong> approach</p><p>You can of course, write the same code programmatically (and actually, more, since XIBs lack some customisations that are possible in code). If performance is key for your app, it’s important to know that the file loading time of a XIB file is slightly longer than building the same UI programmatically. Some developers also go programmatic over XIBs since you have more control, and it can be easier to debug, though more difficult to visualize.</p><p>A never-ending<strong> Storyboard</strong></p><p>A storyboard outlines the sequence of screens in an app, for example a signup flow, and the relationships between them. It can be a great way to visualize the UI flow of certain user journeys, and divide up what would otherwise be a complex navigation sequence into smaller, more manageable flows. Conversely, some dev teams avoid storyboards since it’s hard for multiple developers to work on them at once; and the larger your app the more complicated the web of flows may become.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a7MENAyLkfal2YGjpDZgfw.png" /><figcaption>Example of how storyboard is used to visualise user flows</figcaption></figure><p>As I said earlier, the larger your app gets, the more likely it is that for certain situations and user flows, you will pick which of these suits your needs. Using any of these paths you can create a UIView, in each of which you will have access to the object library to use buttons, labels, switches, the whole shebang! This is particularly easy in IB or Storyboard since dragging and dropping one of these objects is essentially all it takes to add an instance of it into your View. Whichever option you choose, you should try and specify a View’s relative size and position to its superview; creating rules with Auto Layout will then govern how the size/position of the view will change in response to changes in the rest of the view hierarchy.</p><p><strong>Outlets and Actions</strong></p><p>As I said previously, we don’t want any business logic to reside inside the view, since its sole responsibility should be presenting the UI that the ViewController tells it to. Ideally, the View shouldn’t even be <em>aware</em> of the model.</p><p>So, how do we handle user interaction if there’s no logic allowed?</p><p>Outlets are used to make connections between objects in the views, and variables in the code. You can make these connections by ctrl-dragging from the XIB file into the ViewController. Now that we have the reference to the View stored in the ViewController, you have access to its properties and the ability to update them. You might need them, for example, to fetch dynamic text or images; so you simply place an outlet for a View in your ViewController. You don’t need to store references in the ViewController for each and every View in the hierarchy, really only the ones that need to be changed later, or with which you need to specify or report a user interaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3KB6R_fACQKKVgJ8oRfktw.png" /><figcaption>To add a new outlet, action, or outlet collection, ctrl-drag the component from the XIB to the ViewController</figcaption></figure><p>Actions are similar to Outlets, but go in the opposite direction. Outlets are variables that connect code to the layout, and are loaded when the XIB is loaded; using Actions is a way of making layouts trigger code — they are functions that the objects loaded by the XIB can call. An Action takes one argument: a sender. The sender is the specific UI element that will be calling the method. Actions are also created by ctrl-dragging from the View element to the ViewController.</p><p><strong>Context please!</strong></p><p>Let’s say we have a UIView that contains a UIButton and a UILabel. We want the UILabel to change its text when the UIButton is pressed.</p><p>When the UIView’s controller instructs the view to draw itself, the Outlet variables for both the UIButton and UILabel will be loaded, and hence creates their connection from the Interface Builder to the property in the ViewController. You can check that this connection exists by looking in the connections inspector in the inspector toolbar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/216/1*r3pMmxKAvrsndlfncvlQnw.jpeg" /><figcaption>The Connections inspector in XCode</figcaption></figure><p>When a user interacts with the View, for example pressing our UIButton, the relevant Action for that specific UIButton will be triggered, and the ViewController will interpret the interaction; usually a state and/or some information will be passed back to the Model. What will typically happen is the Model will use this information to perform subsequent logic, and will pass its findings to a ViewController (maybe the same one, maybe different). That ViewController in turn will interpret, and will load a View (or Views) which will then draw itself on the screen. In our case, once the Action is triggered, the ViewController will be made aware; and can subsequently perform a function that uses the Outlet tied to the label to change its text.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o-t6eJxLDBnNXQdXKi4T8Q.png" /><figcaption>In this image, the button is linked to an IBAction that will update the label’s text</figcaption></figure><p>Where the ViewController is what handles the events that come down the responder chain, it’s the View that usually handles their own touch events, and reports the results to the ViewController via an associated delegate i.e. our Action method.</p><p><strong>Conclusion</strong></p><p>In this part we’ve covered what a View is, how does it tie in with our MVC model, how we can set one up, and how to use one to allow a user to interact with your UI.</p><p>I’m aware I’ve slightly stepped over into ViewController territory in this post, though it’s difficult to separate the two since each View is managed by a ViewController. We’ll cover a lot more of the responsibilities of a ViewController in our third and final post by our next Swift Wizard, Felix!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f61ded0ef427" width="1" height="1" alt=""><hr><p><a href="https://medium.com/songkick-dev-blog/ios-app-architecture-for-web-developers-f61ded0ef427">iOS App Architecture for Web Developers</a> was originally published in <a href="https://medium.com/songkick-dev-blog">Songkick Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[And That Reminds Me…]]></title>
            <link>https://medium.com/songkick-blog/and-that-reminds-me-6af2b4641afc?source=rss-8994e6151aa8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6af2b4641afc</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[product-and-technology]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[notifications]]></category>
            <dc:creator><![CDATA[Chloe Verity]]></dc:creator>
            <pubDate>Fri, 05 Jul 2019 09:50:53 GMT</pubDate>
            <atom:updated>2019-07-05T12:45:57.372Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine this: <em>those</em> tickets, the ones you simply can’t live without, are going on sale soon, and you absolutely <em>MUST</em> have them. What’s been your go-to plan for being first in line? Setting 15 alarms for when Glasto tickets go on sale at 9 in the morning? Relying on your body clock to know exactly when to log on and buy those Biebs tix? Or maybe you’re waiting to simply *feel* the presence of Beyoncé’s ethereal, all-powerful spirit, and then you’ll just <em>know</em>?</p><p>At Songkick, we’re always trying to make sure that we’ve got your back. With a mantra like “Never miss another concert”, we have to ensure that our users have the best possible access to their favourite concert tickets. That’s why, in our latest iOS release, we’ve made it that much easier for you to be quickest to the punch.</p><h3>Introducing: Notification Reminders!</h3><p>Now, you can decide not only to add an event’s ticket release time to your calendar, but you can also set up reminders that come in the form of push notifications, both of which go off a cool 10 minutes before they go on sale (no more sweating, looking for your phone charger while those T-Swift tickets fly off the e-shelves). And hey, in the event you suddenly fall out of love with her, you can cancel that reminder too — careful though, she might write a song about it.</p><p>Behind the scenes, this first means making use of additional info that we receive from our ticket vendors (where it’s available). Before, while we would receive the ticket onsale time, we wouldn’t use it (only the date). Now we pass both the date and time through the ticket’s API endpoint, as an <strong>ISO8601DateTime</strong>. We do this for not only an accurate time, but also so we can account for timezones — so whether you’re in Taiwan or Timbuktu, you’ll get your Tay Tay tickets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8oeXnUqcmND5pKzfsYeJig.png" /><figcaption>User flow for onsale reminders</figcaption></figure><p>The blue “Notify me” button that appears on each event page (that has an onsale date &amp; time) is tied to this <strong>ISO8601DateTime</strong>, which means the button stays live until 10 minutes before (the reminder is sent 10 minutes before the tickets go on sale).</p><p>The logic behind the local notification seemed daunting at first;</p><blockquote>Timezones! Status Alerts! Permissions! Dispatch Queues! Panic! At the Disco!</blockquote><p>We started by separating the tasks into smaller, actionable sizes — the first of which was creating an action sheet, with the option to set a reminder, or add the event to your calendar. This was easy enough; you simply create the buttons with their respective titles and styles, along with the function they should perform, then add them to your action sheet.</p><p>Now onto the function itself. First, I’ll take you through setting up a local notification.</p><p>Before anything, we have to check that the user has push notification permissions enabled. If the user has no permissions set up, they receive the initial alert. Then, on the main thread, it will try to perform the function again, but they will inevitably now have them either enabled or disabled. If they have them disabled, they will be encouraged to go to settings to change them, but if they’re enabled, then we’ve made it over the first hurdle.</p><p>To schedule the notification itself, we use Xcode’s built in <strong>UNMutableNotificationContent()</strong>, and <strong>DateComponents</strong>. The <strong>DateComponents</strong> allow us to pass in the <strong>ISO8601DateTime</strong>, then manually remove 10 minutes (so that you get your reminder before they go on sale). The <strong>UNMutableNotificationContent</strong> allows us to add a body (with relevant artist name and venue), a sound, and the user info. We can then set up a <strong>UNCalendarNotificationTrigger</strong> using our <strong>DateComponents</strong> and subsequently pass this trigger, along with our notification content (in <strong>UNMutableNotificationContent</strong>) into a <strong>UNNotificationRequest</strong>. This request is then added to the user’s<strong> Notification Center</strong>. Phew!</p><p><em>But that’s not all! </em>To be super snazzy, we added a nice big tick, just to confirm that your reminder is set.</p><p>Remember that action sheet? Well, what if I were to click it again, when I already have a notification set up? Would I be able to set notifications over and over?</p><p>Wrong. When the action sheet loads, it runs a method to check your pending notification requests. If your <strong>Notification Center</strong> is empty, it returns immediately, otherwise it runs through your notifications, looking for one with the specific ID of the event you are looking at. The action sheet contains a “set a reminder” or “remove my reminder” option depending on the result of the <strong>getPendingNotificatonRequests</strong> method.</p><p>Something similar is done in the actual removal process — we search for the notification stored in the <strong>Notification Center</strong> using the event’s ID, and remove the pending request. Again, this comes with a confirmation.</p><p>To get your super amazing reminders, simply click “notify me” on any event. If the release day is available, but not the time, don’t worry. We’ll send you a notification at 10 minutes to 9 so you’re ready no matter what.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*dbeuprmRIDIiP8hswlUV1A.jpeg" /><figcaption>Flow for setting up local notifications</figcaption></figure><p>To recap, here’s how we set up local notification reminders:</p><ol><li>Create an action sheet with a “set reminder” option</li><li>Check the user’s notification permissions</li><li>Set the local notification, passing the onsale time of the ticket to the <strong>DateComponent</strong> to create a trigger, and interpolating the artist name and venue into the <strong>UNMutableNotificationContent</strong></li><li>Add the request to the user’s notification center</li><li>Update the action sheet to look in the notification center for already-scheduled requests</li><li>Finally, set a status alert to let the user know that the reminder is set.</li></ol><p>Happy reminder setting!</p><h4>How does our team sound? <a href="https://www.songkick.com/jobs">We’re hiring!</a></h4><p><a href="https://developer.apple.com/design/human-interface-guidelines/ios/views/action-sheets/">Action Sheets</a> || <a href="https://developer.apple.com/documentation/usernotifications/asking_permission_to_use_notifications">Notification Permissions</a> || <a href="https://developer.apple.com/documentation/usernotifications/scheduling_a_notification_locally_from_your_app">Local Notifications</a> || <a href="https://developer.apple.com/documentation/foundation/datecomponents">DateComponents</a> || <a href="https://developer.apple.com/documentation/usernotifications/unmutablenotificationcontent">UNMutableNotificationContent</a> || <a href="https://developer.apple.com/documentation/foundation/notificationcenter">NotificationCenter</a> || <a href="https://developer.apple.com/design/human-interface-guidelines/ios/views/alerts/">Status Alerts</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6af2b4641afc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/songkick-blog/and-that-reminds-me-6af2b4641afc">And That Reminds Me…</a> was originally published in <a href="https://medium.com/songkick-blog">Songkick</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>