<?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 Piotr Gorzelany on Medium]]></title>
        <description><![CDATA[Stories by Piotr Gorzelany on Medium]]></description>
        <link>https://medium.com/@piotr.gorzelany?source=rss-7114b3d7b439------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*SieabIQ4CYgB8QTKPPswXg.jpeg</url>
            <title>Stories by Piotr Gorzelany on Medium</title>
            <link>https://medium.com/@piotr.gorzelany?source=rss-7114b3d7b439------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:06:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@piotr.gorzelany/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[Creating a Children’s Story Podcast with AI]]></title>
            <link>https://medium.com/@piotr.gorzelany/creating-a-childrens-story-podcast-with-ai-259616ec9505?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/259616ec9505</guid>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[podcast]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[storytelling]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Thu, 06 Apr 2023 16:58:47 GMT</pubDate>
            <atom:updated>2023-04-06T16:58:47.346Z</atom:updated>
            <content:encoded><![CDATA[<h4>How I transformed from programmer to children story author and podcaster overnight</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*LTJ8c7YyAP2kKqj_qLgsjA.jpeg" /><figcaption>A DALL-E generated cover image for the podcast</figcaption></figure><h4>TL;DR</h4><p>In this blog post, I share my experience using AI tools like ChatGPT, murf.ai, and DALL-E to create a series of children’s stories and transform them into a podcast. As a programmer, I was curious to explore the hype around GPT and see how it could help me save time and complete a fun project for my son. You can find the link to the results <a href="https://open.spotify.com/show/2bLBeNSxgnuL403JDKb4bu">on Spotify</a>.</p><h4>Introduction</h4><p>AI tools have the potential to revolutionize creative fields, and as a programmer, I wanted to explore what was behind the hype around ChatGPT. With limited time and writing skills, I embarked on a fun project to create a series of personalized children’s stories for my four-year-old son, transforming them into a podcast with the help of other AI tools like murf.ai, and DALL-E.</p><h4>Leveraging AI Tools in the Creative Process</h4><p>The creative process began with using ChatGPT to brainstorm story ideas, develop characters, and create episode outlines. It then generated short descriptions and morals for each of the 10 episodes as well as the stories themselves. With the help of murf.ai, I converted the text into speech and uploaded the audio files to Spotify. ChatGPT also assisted in generating the podcast name, description, and episode descriptions, while DALL-E was used to create the cover image.</p><h4>Overcoming Challenges with AI Tools</h4><p>While ChatGPT excelled in generating text, finding a high-quality text-to-speech tool was challenging. Murf.ai was the best option I found, but there’s still room for improvement in terms of producing human-like speech. To help others facing similar challenges, I recommend researching multiple AI tools and being prepared to experiment with different settings to achieve the desired results.</p><h4>Reception and Feedback</h4><p>The podcast hasn’t garnered many listens, and I admit that the quality isn’t as high as I’d like it to be. If you’re curious to check it out, you can listen to the podcast on Spotify <a href="https://open.spotify.com/show/2bLBeNSxgnuL403JDKb4bu">here</a>.</p><h4>Future Plans for Improvement</h4><p>I plan to improve the quality of the stories by experimenting with different prompts for ChatGPT and searching for the best-sounding text-to-speech tool.</p><h4>Lessons Learned and Time Saved</h4><p>Working on this project allowed me to explore the potential of AI tools in creative projects. I learned that using AI tools like ChatGPT can save significant time and make it possible to complete projects, like this podcast, that might not have been feasible otherwise due to time constraints.</p><h4>Conclusion</h4><p>Creating a children’s story podcast with AI tools like ChatGPT, murf.ai, and DALL-E has been an exciting journey. Although the podcast’s quality is not yet perfect, this experience has shown me the potential of AI in storytelling and creative projects. With continued experimentation and improvement, the possibilities are looking good.</p><p>I would love to hear your thoughts on the podcast and if you have any recommendations for high-quality text-to-speech tools. Please share your experiences and ideas in the comments below. Together, we can continue exploring the potential of AI in creative projects and find the best tools for the job.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=259616ec9505" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing SwiftConfiguration]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/better-programming/introducing-swiftconfiguration-c3cba2002965?source=rss-7114b3d7b439------2"><img src="https://cdn-images-1.medium.com/max/2600/1*IaPhwvwogazpjAIT05qhAw.jpeg" width="4076"></a></p><p class="medium-feed-snippet">Compile time validation and wrapper-class generation for configuration files in iOS projects</p><p class="medium-feed-link"><a href="https://medium.com/better-programming/introducing-swiftconfiguration-c3cba2002965?source=rss-7114b3d7b439------2">Continue reading on Better Programming »</a></p></div>]]></description>
            <link>https://medium.com/better-programming/introducing-swiftconfiguration-c3cba2002965?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3cba2002965</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[xcode]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Thu, 21 Nov 2019 12:01:54 GMT</pubDate>
            <atom:updated>2019-11-28T03:24:47.913Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Managing Configuration-Dependent Variables in iOS Projects]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/better-programming/managing-configuration-dependent-variables-in-ios-projects-b68bfb0f9689?source=rss-7114b3d7b439------2"><img src="https://cdn-images-1.medium.com/max/1920/1*TMM7BJOflHvgiU-eqXkLIg.jpeg" width="1920"></a></p><p class="medium-feed-snippet">A step-by-step guide for Xcode setup</p><p class="medium-feed-link"><a href="https://medium.com/better-programming/managing-configuration-dependent-variables-in-ios-projects-b68bfb0f9689?source=rss-7114b3d7b439------2">Continue reading on Better Programming »</a></p></div>]]></description>
            <link>https://medium.com/better-programming/managing-configuration-dependent-variables-in-ios-projects-b68bfb0f9689?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/b68bfb0f9689</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[xcode]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Fri, 30 Aug 2019 15:18:04 GMT</pubDate>
            <atom:updated>2019-11-28T22:13:06.367Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[iOS project best practices and tools]]></title>
            <link>https://medium.com/@piotr.gorzelany/ios-project-best-practices-and-tools-c46135b8116d?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/c46135b8116d</guid>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[xcode]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Mon, 28 Jan 2019 11:01:00 GMT</pubDate>
            <atom:updated>2019-12-30T00:11:14.349Z</atom:updated>
            <content:encoded><![CDATA[<h4>With an open-source Xcode project template</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X0JyUGqmtUd3XOoKzhJzLw.png" /><figcaption>Thanks to <a href="https://lukaszadam.com/illustrations">Lukas</a> for the illustration</figcaption></figure><p>When working on greenfield iOS projects I often had to start a new project from scratch. While doing so, me and my team were always spending a lot of time on basic project setup like integrating tools, setting up the project structure, writing base classes, integrating external libraries, etc.</p><p>I decided that the time spent on project startup could be saved and the process could be mostly automated. I wrote down all the usual best practices and tools we used and prepared a <a href="https://github.com/pgorzelany/iOS-project-template">project template</a> that me and my team could use when starting new projects. This <a href="https://github.com/pgorzelany/iOS-project-template">template</a> should save project setup time and also provide a common foundation that each team member will be accustomed to so that you don’t have to think and explore the project structure and foundations. They will always be the same.</p><p>Each and every tool or best practice included in the template deserve an article on its own but I wanted to try and sum up each point and give a brief explanation of why I included them.</p><h4>Cocoapods</h4><p>I don’t think this one needs an introduction. This is <a href="https://cocoapods.org/"><strong>the</strong></a> library for managing external dependencies for iOS projects. It’s been around for a long time and is robust and battle tested in thousands (if not millions) of projects. There are alternative dependency managers out there like Carthage but I decided to go with Cocoapods because it has the widest range of open source project that it supports. Using Cocoapods is very easy and it comes with a <a href="https://cocoapods.org/">search index</a> that lets you easily discover packages that you may need.</p><p>The template project comes with a simple <a href="https://guides.cocoapods.org/syntax/podfile.html">Podfile</a> that includes Swiftlint and R.swift. The template also includes a <a href="https://guides.cocoapods.org/using/a-gemfile.html">Gemfile for managing the Cocoapods</a> version used to resolve the dependencies. This is an often overlooked improvement that prevents issues arising when developers on your team install dependencies using different versions of Cocoapods itself. The Gemfile enforces using the same Cocoapods version across the whole team.</p><h4>Swiftlint</h4><p><a href="https://github.com/realm/SwiftLint">Swiftlint</a> is a very useful tool for enforcing certain rules and coding style for every programmer on the team. You can think of it as an automated code review system that warns the programmer about dangerous things like force unwraps, force casts, force tries etc. but also enforces a common coding style by making sure all programmers follow the same “code style” related rules like indentation or spacing rules. This has tremendous benefits of not only saving code review time by doing those basic checks, but also it makes all files in the project look familiar which increases their readability and as a result their understanding by all the devs. You can find a list of all the rules <a href="https://github.com/realm/SwiftLint/blob/master/Rules.md">here</a>. In the template, Swiftlint is installed via Cocoapods and included in the Build Phases step so it lints and warns the developer at every project build.</p><h4>R.swift</h4><p>R.swift is a tool for getting strongly typed, autocomplete resources like images, fonts segues and localizations. It does this by scanning your project and generating swift classes needed to get the resources. The biggest selling point of this library is that while using resources it makes your code:</p><ul><li><strong>Fully typed</strong> — less casting and guessing what a method will return</li><li><strong>Compile time checked</strong> — no more incorrect strings that make your app crash at runtime</li><li><strong>Autocompleted</strong> —<strong> </strong>never have to guess that image/nib/storyboard name again</li></ul><p>Consider the following code using the official string API:</p><pre>let icon = UIImage(named: “custom-icon”)</pre><p>If you misspell the image name you will get a nil here. If any member of your team changes the name of the image resource this code will return nil or will crash if you force unwrap the image. When using R.swift this becomes:</p><pre>let icon = R.image.customIcon()</pre><p>Now you can be sure that the icon really exists (the compiler will warn you if it does not thanks to compile time checks) and you are sure you will not make a typo in the icon name since you will be using autocomplete.</p><p>R.swift is installed via Cocoapods and integrated in the template as a Build Phase and will generate the Swift wrapper classes on each build. That means if you add a file/image/localization/font/color/nib etc. it will be available to you using R.swift once you compile the project.</p><h4>Separate AppDelegate for tests</h4><p>An often overlooked good practice is to have a <a href="https://marcosantadev.com/fake-appdelegate-unit-testing-swift/">separate TestAppDelegate</a> class when running tests. Why is it a good idea? Well, usually the AppDelegate class does a lot of work at app startup. It could set up a window, build the basic UI structure of the app, register for notifications, set up a database and even sometimes make API calls to some backend service. Unit tests should not have any side effects. Do you really wan’t to make random api calls and setup all of the UI structure of your app just to run some unit tests?</p><p>The TestAppDelegate is also a great place to have code that you only want run once during your test suite execution. It could contain code that generates mocks, stubs network requests etc.</p><p>The template contains a <a href="https://github.com/pgorzelany/iOS-project-template/blob/master/%7B%7Bcookiecutter.app_name%7D%7D/%7B%7Bcookiecutter.app_name%7D%7D/main.swift">main.swift</a> file which is the main entry point for the app. This file has methods that check what is the environment the app is currently running and if it’s the test environment, invokes the TestAppDelegate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1kwExAXA4lNas7zYeAe3nQ.jpeg" /></figure><h4>Compiler performance profiling flags</h4><p>Swift is a great language, easier to use and much safer than Objective-C (IMO). But when it was first introduced it had one big downside — compile times. Back in the Swift 2 days, I was working on a project that had roughtly 40k lines of Swift code (a medium sized project). The code was very heavy with generics and type inference and it took nearly 5 minutes to compile a clean build. When you made even a small change, the project would recompile and took around 2 minutes to see the change. That was one of the worst developer experiences I ever had and I nearly stopped using Swift because of it.</p><p>The only solution back then, was to try and profile the compile times of the project and try to change your code in such a way, that would make the compiler faster. To help with this, Apple introduces some <a href="https://www.jessesquires.com/blog/measuring-compile-times-xcode9/">unofficial compiler flags</a> which would warn you when compiling a method body or resolving the type of an expression took too long. I added those flags to the template project so you will be warned from the start about long compile times for you app.</p><p>Nowadays the build times have been <strong>dramatically</strong> improved and you very rarely need to tweak your code just to improve build times. But still it’s better to know up front then to try to fix the problem when the project gets too big.</p><h4>Dev/Staging/Production configurations</h4><p>Another good practice (or may I say necessity) is to have separate configurations and environment variables for the development, staging and production environments. Almost every app nowadays have to connect to some kind of backend service and usually, those services are deployed on multiple environments. The development environment is used for daily deploys and for devs to test their code. The staging environment is used for stable releases for testers and clients to test. We all know what the production environment is for.</p><p>One way to support multiple environments in an iOS project is to add project level configurations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0eq6eRQuZ8Hom-8g8m86_g.png" /><figcaption>Project level configurations</figcaption></figure><p>Once you defined the configurations, you can create a Configuration.plist file containing the variables for each environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DXQqpMM3dzSX8PIQM3ws2A.png" /><figcaption>Configuration.plist</figcaption></figure><p>When running the project, you can specify which configuration should be used. You can do this in the build scheme.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*33wqtx027JuT1B92Qw-pdQ.png" /></figure><p>You then need to add one additional property in the project Info.plist file. The value of this property will be dynamically resolved at runtime to the name of the current configuration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xeQO8CI8_WDaw4lwaDq9Ew.png" /></figure><p>This is all preconfigured for you in the template.</p><p>The only thing left is to write a class that can retrieve those variables at runtime depending on the configuration selected in the build scheme. The template contains a <a href="https://github.com/pgorzelany/iOS-project-template/blob/master/%7B%7Bcookiecutter.app_name%7D%7D/%7B%7Bcookiecutter.app_name%7D%7D/Helpers/Utilities/ConfigurationManager.swift">ConfigurationManager</a> class that can retrieve the variables for the current environment. You can check the implementation of that class on Github to see how it works.</p><h4>Readme</h4><p>Every project should have a basic Readme that at least has instructions how to install dependencies and run the project. It should also contain descriptions of the project architecture and modules. Unfortunately, developers don’t like to write documentation (a readme is part of that) and I have seen the project that were being developed for months and they did have even a basic Readme. To take away the burden of writing this basic readme, the template contains a <a href="https://github.com/pgorzelany/iOS-project-template/blob/master/%7B%7Bcookiecutter.app_name%7D%7D/Readme.md">standard readme</a> that covers installation and project structure. When you set up a new project using the template, you will have the Readme included automatically.</p><h4><strong>Gitignore</strong></h4><p>Nowadays, most projects use GIT as their version control system. When using GIT, you usually wan’t to ignore some files or folders in the project like the build folder or the derived data folder. To save you the trouble of searching for a gitignore file that suits your iOS project, the template includes a <a href="https://github.com/github/gitignore/blob/master/Swift.gitignore">standard gitignore</a> provided by Github contributors.</p><h4>Base classes for handling deeplinks and notifications</h4><p>Almost every app nowadays has to handle deeplinks and notifications. To do this, a developer has to write some amount of boilerplate code in the AppDelegate class. The template has that covered and also provides <a href="https://github.com/pgorzelany/iOS-project-template/tree/master/%7B%7Bcookiecutter.app_name%7D%7D/%7B%7Bcookiecutter.app_name%7D%7D/Helpers/Utilities">base classes</a> that make working with deeplinks and notifications easier.</p><h3>Summary</h3><p>To sum up, the <a href="https://github.com/pgorzelany/iOS-project-template">template</a> tries to include best practices and integrates useful third-party tools. This should save you and our team hours spent on new project setup and also provide a common and strong foundation for the rest of the project. May it serve you well!</p><p>PS: If you have any issues or feature requests for the template just leave me an issue on Github. I will try to resolve it in my free time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c46135b8116d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[6 tips for a more efficient mobile MVP]]></title>
            <link>https://medium.com/@piotr.gorzelany/an-efficient-ios-mvp-d26beddbd564?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/d26beddbd564</guid>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Sun, 06 Aug 2017 12:51:34 GMT</pubDate>
            <atom:updated>2019-01-19T19:49:03.071Z</atom:updated>
            <content:encoded><![CDATA[<h4>From an iOS developer perspective</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3TESsdxkkHDKjFYVRvUN9A.jpeg" /></figure><p><em>Disclaimer: This article is written from a point of view of a software developer. I optimize the efficiency of development and do not touch other business areas.</em></p><p>As an iOS developer working in a software house, I deal almost exclusively with very early stage startups. Most of the clients I work for only have an initial idea and they want us to deliver the first MVP version of their app.</p><p>For an early stage startup time is precious. Chances are that you don’t have a clear vision of your product and you have limited and time constrained funding. If you don’t make it in the first year, there is a big chance that you won’t make it at all. Funding will dry up, people will start to leave etc.</p><p>From this perspective, it is extremely important that time spent on development is used efficiently so you still have time to market the product before all the funds are gone.</p><p>While working with multiple startups I have started to notice patterns of the same mistakes repeated over and over again that hinder the release of an MVP. I like my clients to succeed so this is my take on things that can be improved to deliver a successful MVP.</p><ul><li>Communicate with your developers</li><li>Create a design mockup</li><li>Do not pack too much functionality in the initial release</li><li>Do not obsess about UI</li><li>Have a marketing plan and budget</li><li>Have a vision for the future after the MVP</li></ul><h4>Communicate with your developers</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EZk40FSSOPa6ddDVG-1dJg.jpeg" /><figcaption>Source: Pixabay.com</figcaption></figure><p>Developers cannot read your mind. You and only you know how your product should look and function. You should try to communicate that vision clearly and be patient. What is obvious to you is not obvious to people that are trying to implement you MVP.</p><p>Be responsive. Even the most detailed documentation does not cover every functionality and corner case. Sometimes the developer may hit o wall and tries to reach you to try to create a solution. Development may move forward much quicker when the founder is responsive and the developers do not need to wait for hours to implement an unclear functionality.</p><h4>Create a design mockup</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BDPmQF_P6-ujQm7bJl3G1A.jpeg" /><figcaption>Source: Pixabay.com</figcaption></figure><p>Creating a design mockup or a detailed design is a great idea mostly because you can see the outcome of the development for little effort and play with your mockup. It takes a lot less time to create a mockup with a clickable flow than developing the full app functionality. There are great tools out there like <a href="https://www.invisionapp.com/">Invision</a> that will simplify the process for you.</p><p>Once you get a phone in your hand and start clicking you will get a clearer idea of the UX, but you will inevitably want to make changes to the design to improve the app. You can change the design a hundred times using tools like Photoshop while working with a good designer in little time. Asking the developer to do this will take way more time and transform the code base into a hot mess.</p><p>It is also way easier for me as a developer to create the app if I know how it should look and function.</p><h4>Packing excessive functionality in the initial release</h4><p>What does MVP mean? It is the <strong>minimum</strong> viable product, not the full-fledged, million lines, thousand features Facebook app.</p><p>A product is never finished, you just have to accept that. It is much better to release a small version of the app with core functionality and see what is the market reaction rather than trying to pack more and more features into an app until the funds dry up. Once the initial release is done you can always release an update and you can do it as often as you like.</p><p>A simple app for a startup has the following benefits:</p><ul><li>It is easier and faster to developer (costs less)</li><li>It has fewer bugs since its simple</li><li>It creates a stable base to build new features</li><li>The client feedback is streamlined to core functionalities</li><li>Its usually better user experience</li></ul><h4>Obsessing about UI</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X6jzEGtbMtOW4eoQJcDImQ.jpeg" /><figcaption>Source: Pixabay.com</figcaption></figure><p>The UI is important. It’s something that differentiates your app from competition and builds user experience. But obsessing over minor UI details can extend the development time into infinity and cost you a lot of money and finally your startup.</p><p>There are native ways to do something that is familiar to users, reliable and easy to implement and for an MVP your best bet is to just go with the defaults. Sure we can create this super cool animation or effect and make everything super smooth but that will greatly increase development time with IMO little functionality gain. A user will glance at the super effect you designed and I was implementing for a week and for a split second think “that was cool”. But if your app does not provide useful functionality, no UI or special effects will save you from failure.</p><p>Iron out the core functionality, release the product and then polish the UI based on real user feedback.</p><h4>Have a marketing plan</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g78ATX6AmIAVv7_yY49G2A.png" /><figcaption>Source: Pixabay.com</figcaption></figure><p>The app market at this point is really crowdy. There are over 2 million apps in the app store. The hard truth is that no matter how good your idea is and how great your product is nobody will use it without marketing.</p><p>Too many times I have seen startups burn through all their funding in the development phase (by making the above mistakes and delaying the first release). Then when the app is finally released, no funding is set aside for marketing and the app gets 0 downloads. In the current app market marketing is essential for success. You may be lucky and if your app is really good it may go viral on its own, but don’t count on it. It is more probable that it will just drown in the sea of other apps.</p><h4>What lies beyond the MVP?</h4><p>Remember that the MVP is just the beginning. Do not treat it as the ultimate goal you want to reach and then you can open up the champagne and sit back watching your app popularity skyrocket. So much more work is ahead of you. Marketing, monetization, pivoting, hiring people, organizing the office etc. Be prepared and get that MVP out to market as fast as you can!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d26beddbd564" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Experimental Swift]]></title>
            <link>https://medium.com/@piotr.gorzelany/experimental-swift-8c9131b62a9d?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c9131b62a9d</guid>
            <category><![CDATA[server-side-swift]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Thu, 04 May 2017 09:49:54 GMT</pubDate>
            <atom:updated>2018-02-13T09:37:07.709Z</atom:updated>
            <content:encoded><![CDATA[<p>iOS + Swift Server + Raspberry Pi = Madness</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A8YtBzAztFcFI9hLa2tP6g.jpeg" /><figcaption>Image taken from raspberrypi.org</figcaption></figure><p>This blog post is a continuation of my <a href="https://hackernoon.com/setting-up-a-swift-development-environment-on-raspberry-pi-c7af7fceac1e">previous blog</a> posts exploring Swift on the Raspberry Pi platform.</p><p>In my previous adventure, I implemented controlling an LED attached to a Raspberry Pi through Swift code. It was cool but you know what would be more fun than blinking LEDs with Swift? Controlling LEDs and other devices with an iPhone through a Swift server running on a Raspberry Pi!</p><p>I started out with drawing a rough diagram of the architecture of the system. It looks something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zcrvvV7Ny46vICed5yrO5Q.png" /><figcaption>System architecture</figcaption></figure><p>The basic idea is that an iOS app will communicate with a server running on the Pi through standard HTTP methods and the server will control the hardware through the GPIO library. Simple as that.</p><p>First, I implemented the iOS app which is my bread and butter. What the app does is it first scans the local network looking for the Pi. Once the Pi is found you configure the app with its IP address. Then the only thing left to do is to implement simple api calls that will be executed on the Rasberry on each action like switching the LED on/off or blinking it.</p><p>I took a look at the server frameworks available for Swift on Linux. Out of the most popular frameworks (<a href="https://github.com/vapor/vapor">Vapor</a>, <a href="https://github.com/IBM-Swift/Kitura">Kitura</a>, <a href="https://github.com/PerfectlySoft/Perfect">Perfect</a>) I selected Vapor since it seemed the most user-friendly at the time. It had command line tools for creating projects and a nice api.</p><p>For controlling the hardware I used <a href="https://github.com/uraimo/SwiftyGPIO">SwiftyGPIO</a>. To make it all easier to use I wrapped the whole Raspberry system into an object-oriented interface by defining a protocol:</p><pre>protocol RaspberryApi: class {<br>    func switchLedOn()<br>    func switchLedOff()<br>    func startLedBlink()    <br>    func stopLedBlink()<br>    func setLedIntensity(_ intensity: Double)<br>    func displayDigit(_ digit: OneDigitSegmentDisplay.Digit)<br>    func switchDigitDisplaySegmentOff()<br>    func toggleRGBLedColor(_ color: RGBLed.Color)<br>}</pre><p>I implemented two concrete classes conforming to the procol. The MockRaspberry for testing and running on the Mac (SwiftyGPIO is not available on the Mac), and the Raspberry class that is actually responsible for controlling the hardware on Linux. The concrete class was selected at runtime given the underlying os the code was running. For this I implemented a factory class:</p><pre>final class RaspberryFactory {<br>    <br>    static func getRaspberry() -&gt; RaspberryApi {<br>        let raspberry: RaspberryApi<br>        <br>        #if os(Linux)<br>            raspberry = Raspberry.shared<br>        #else<br>            raspberry = MockRaspberry.shared<br>        #endif<br>        <br>        return raspberry<br>    }<br>}</pre><p>I was pleasantly surprised by how easy it was to implement the api with Vapor. A couple of lines of code gave me a working api that the iOS app could communicate with!</p><pre>import Vapor</pre><pre>let drop = Droplet()<br>let raspberry = RaspberryFactory.getRaspberry()</pre><pre>drop.get { req in<br>    return &quot;Success&quot;<br>}</pre><pre>drop.patch(&quot;led&quot;, &quot;switch_on&quot;) { (request) in<br>    raspberry.switchLedOn()<br>    return &quot;OK&quot;<br>}</pre><pre>drop.patch(&quot;led&quot;, &quot;switch_off&quot;) { (request) in<br>    raspberry.switchLedOff()<br>    return &quot;OK&quot;<br>}</pre><pre>drop.patch(&quot;led&quot;, &quot;start_blink&quot;) { (request) in<br>    raspberry.startLedBlink()<br>    return &quot;OK&quot;<br>}</pre><pre>drop.patch(&quot;led&quot;, &quot;stop_blink&quot;) { (request) in<br>    raspberry.stopLedBlink()<br>    return &quot;OK&quot;<br>}</pre><pre>drop.patch(&quot;led&quot;, &quot;intensity&quot;) { (request) in<br>    guard let intensity = request.query?[&quot;intensity&quot;]?.double else {<br>        throw Abort.badRequest<br>    }<br>    <br>    raspberry.setLedIntensity(intensity)<br>    return &quot;Ok&quot;<br>}</pre><pre>drop.patch(&quot;digitSegment&quot;, Int.self) { (request, digit) in<br>        guard let digit = OneDigitSegmentDisplay.Digit(rawValue: digit) else {<br>            throw Abort.badRequest<br>        }<br>        raspberry.displayDigit(digit)<br>        return &quot;OK&quot;<br>    }</pre><pre>drop.patch(&quot;digitSegment&quot;, &quot;switchOff&quot;) { (request) in<br>        raspberry.switchDigitDisplaySegmentOff()<br>        return &quot;OK&quot;<br>    }</pre><pre>drop.patch(&quot;rgbLed&quot;, RGBLed.Color.self, &quot;toggle&quot;) { (request, color) in<br>        raspberry.toggleRGBLedColor(color)<br>        return &quot;OK&quot;<br>    }</pre><pre>drop.run()</pre><p>And that’s it! I was able to communicate with the server running on the Pi with my iPhone. Now I could control my precious little LEDs and Segment Displays even when I was in the other room or the balcony. So convenient!</p><p>This is the system in action:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FI4PXZq2rBQU%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DI4PXZq2rBQU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FI4PXZq2rBQU%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/96bdb13c00dc718fe56a2d63c8cd6f5e/href">https://medium.com/media/96bdb13c00dc718fe56a2d63c8cd6f5e/href</a></iframe><p><strong>Conclusion:</strong></p><p>Almost all of the technology used to create this system is experimental at this point. Starting with Swift on ARM Linux, through SPM, Vapor and the GPIO library.</p><p>That said I was really pleasantly surprised by how little problems I had with setting this up. The whole coding for this took a couple of hours at most and the effect is really cool. I was really surprised by how simple the server side code turned out to be. Having mostly done iOS work before I thought that the server will be the most difficult part to implement but it turned out just ~50 lines of code. Way to go Vapor!</p><h4>Next steps:</h4><p>Having the basics figured out I can now create more complex systems based on this proof of concept one. Some nice projects that come to mind would be a humidity sensor attached to a flower that would send text messages to my iPhone when the humidity is to low. Or controlling a motor that would water the plant through my iPhone.</p><p>Let me know if you have any cool ideas :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c9131b62a9d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting up a Swift development environment on Raspberry Pi]]></title>
            <link>https://medium.com/hackernoon/setting-up-a-swift-development-environment-on-raspberry-pi-c7af7fceac1e?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7af7fceac1e</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Tue, 07 Feb 2017 22:13:03 GMT</pubDate>
            <atom:updated>2019-05-09T04:05:25.263Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A8YtBzAztFcFI9hLa2tP6g.jpeg" /><figcaption>Image taken from raspberrypi.org</figcaption></figure><p>In my <a href="https://medium.com/@piotr.gorzelany/the-state-of-swift-on-raspberry-pi-f23445418ee2#.4drnxi3pp">previous post</a>, I gave an overview of the current state of Swift on the Raspberry Pi platform. In this post, I will try highlight how to set up a pleasant development environment to write Swift code on the Pi.</p><p>One of the biggest pains right now when writing Swift code on any Linux platform is the lack of a real IDE. Sure, you may hate Xcode but go start typing your program in Nano on the command line and you will see how real misery feels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/1*7PnS86DfUtd8l5uFesqE2A.png" /><figcaption>You get a lot of these since you do not have compiler warnings at write time</figcaption></figure><p>The first step for a good development experience is a good IDE and the best Swift IDE for Linux right now is…. Xcode.</p><p>What!? But Xcode does not work on Linux. How do I install it on the Pi? Well, you don’t, and frankly, you would not want to write code on the Pi. It is a slow computer and running it with a monitor and keyboard is unnecessary. So where do I write my code? On your Mac of course, where else dummy.</p><p>The first thing you need to do is setup a headless Pi. There is a really nice tutorial on how to do that on the <a href="https://www.raspberrypi.org/forums/viewtopic.php?t=74176">Raspberry forums</a>. The tutorial is written for Raspian and I recommend using Ubuntu for the Pi since the SPM works there. I first ran my Pi with a keyboard and monitor and did the initial setup and connected it to my WiFi <a href="https://hackernoon.com/tagged/network">network</a>. Once you have the Pi connected to your router you can start controlling it by <a href="https://en.wikipedia.org/wiki/Secure_Shell">SSH</a> from your mac. First, you need to find the IP address of your Pi on the network. I do that using nmap which scans devices in your network that listed on port 22 (ssh port).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/1*3O9E36Rwqd6pw_xWPEkesw.png" /></figure><p>To find your Pi, you need to replace the 192.168.6.0 part with your local address space. Once you have it, connect your mac through ssh.</p><pre>ssh {your-pi-username}@{you-pi-ip-address}</pre><p>And there you go, the sky is the limit now. Try to build and run your first Swift script remotely on the Pi.</p><pre>// Create the script<br>echo &quot;print(\&quot;hello from swift\&quot;)&quot; &gt;&gt; hello.swift</pre><pre>// Run it<br>swift hello.swift</pre><p>This is all fine and dandy but what are you still doing on the command line? Go fire up Xcode and begin some serious development!</p><p>We will create a program that will switch on and off an LED connected to the Pi if you press the return key on your Mac. To switch nicely between the two environments we will use the <a href="https://www.raywenderlich.com/148832/introduction-swift-package-manager">Swift Package Manager</a>, which is a system-agnostic dependency manager for Swift. It runs fine both on OS X and on Linux and it will be a vital part that will enable us to develop code on the Mac and run it on the Pi.</p><pre>// create the project folder<br>mkdir led-blink<br>// go to the folder<br>cd led-blink<br>// initialize the swift project using SPM<br>swift package init --type executable</pre><p>You should now have the directory structure and main.swift file generated by SPM. Edit the Package.swift to include the <a href="https://github.com/uraimo/SwiftyGPIO">GPIO swift library</a>.</p><pre>import PackageDescription</pre><pre>let package = Package(<br>    name: &quot;led-blink&quot;,<br>    dependencies: [<br>        .Package(url: &quot;https://github.com/uraimo/SwiftyGPIO.git&quot;, majorVersion: 0)<br>    ]<br>)</pre><p>Now fetch the library using the command:</p><pre>swift package update</pre><p>You can now use SPM to generate an Xcode project for you! Do this using the command:</p><pre>swift package generate-xcodeproj</pre><p>Open the generated Xcode project and build it (cmd+B), so the compiler knows about the SwiftyGPIO library. Voila, you can now use Xcode to develop your program, having access to all those sweet <a href="https://hackernoon.com/tagged/tools">tools</a> like code completion, syntax highlighting, compiler errors, documentation and more.</p><p>Open the main.swift file and add the following code:</p><pre>import SwiftyGPIO<br>import Foundation</pre><pre>// Get a dictionary of all the gpio pins<br>let gpios = SwiftyGPIO.GPIOs(for: .RaspberryPi2)</pre><pre>// Get the pin that you connected the LED to. Remember to set the right pin number, for me it was 27<br>guard let ledGpio = gpios[GPIOName.P27] else {<br>    fatalError(&quot;Could not initialize the gpio&quot;)<br>}</pre><pre>// Set the pin direction to .OUT and turn it off<br>ledGpio.direction = .OUT<br>ledGpio.value = 0</pre><pre>// Read user input from keyboard and switch the LED on/off each time the user presses the return key</pre><pre>print(&quot;Press return to switch the LED on/off. To quit type exit&quot;)<br>while let userInput = readLine(strippingNewline: true), userInput != &quot;exit&quot; {<br>    print(&quot;Switching LED&quot;)<br>    ledGpio.value = ledGpio.value == 0 ? 1 : 0<br>}</pre><p>Ok, the program is completed. The only thing left to do is to build and run it on the Pi. To do this, you will need to copy the project you created on your mac to the Pi. There are a couple of solutions how you might do it. For one, you could create a GIT repository and host it on Github. Then you would push the changes from your mac, and pull them on the Pi. Another option is to use SCP to copy the folder.</p><pre>scp -r {path-to-project-folder-on-mac} {your-pi-username}@{you-pi-ip-address}:{path-to-folder-on-pi}</pre><p>Once you copied the project, you can ssh to the Pi and go to the project folder. The folder has all the files there but you still have to build it using the compiler on the Raspberry.</p><pre>swift build</pre><p>Should create an executable which you can then run and marvel at your work! Here is the masterpiece I’ve created in action.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fr1bNXMWGgjQ%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dr1bNXMWGgjQ&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fr1bNXMWGgjQ%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/31e5616ce503c3e746611a2c5082b80c/href">https://medium.com/media/31e5616ce503c3e746611a2c5082b80c/href</a></iframe><h4>Conclusion:</h4><p>Developing for the Pi is not that painful once you can use your familiar environment on the Mac. Using this technique you can develop your programs faster using Xcode.</p><p>The workflow looks roughly like this: Write code on Mac -&gt; Copy to Pi -&gt; Build and run on Pi</p><p>This process can easily be completely automated but I just didn’t have time to do it.</p><p>Using this setup I plan to use Xcode to develop a server application, run it on the Pi, and control LEDs with my iPhone. Fingers crossed.</p><figure><a href="http://bit.ly/HackernoonFB"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hqOaABQ7XGPT-OYNgiUBg.png" /></a></figure><figure><a href="https://goo.gl/k7XYbx"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vgw1jkA6hgnvwzTsfMlnpg.png" /></a></figure><figure><a href="https://goo.gl/4ofytp"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKBpq1ruUi0FVK2UM_I4tQ.png" /></a></figure><blockquote><a href="http://bit.ly/Hackernoon">Hacker Noon</a> is how hackers start their afternoons. We’re a part of the <a href="http://bit.ly/atAMIatAMI">@AMI</a> family. We are now <a href="http://bit.ly/hackernoonsubmission">accepting submissions</a> and happy to <a href="/service/mailto:partners@amipublications.com">discuss advertising &amp; sponsorship</a> opportunities.</blockquote><blockquote>If you enjoyed this story, we recommend reading our <a href="http://bit.ly/hackernoonlatestt">latest tech stories</a> and <a href="https://hackernoon.com/trending">trending tech stories</a>. Until next time, don’t take the realities of the world for granted!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7af7fceac1e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/setting-up-a-swift-development-environment-on-raspberry-pi-c7af7fceac1e">Setting up a Swift development environment on Raspberry Pi</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The state of Swift on Raspberry Pi]]></title>
            <link>https://medium.com/@piotr.gorzelany/the-state-of-swift-on-raspberry-pi-f23445418ee2?source=rss-7114b3d7b439------2</link>
            <guid isPermaLink="false">https://medium.com/p/f23445418ee2</guid>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Piotr Gorzelany]]></dc:creator>
            <pubDate>Fri, 27 Jan 2017 22:30:19 GMT</pubDate>
            <atom:updated>2019-07-25T08:50:14.328Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Edit (April 2019): The original post was written in January 2017 back in the Swift 3.0 days when Linux support was still young. As of this edit Swift is on the 5.0 release and Linux support is much better then it used to be. If you are looking for up to date information about Swift on Raspberry Pi and precompiled Swift binaries that you can use on the system I recommend visiting </strong><a href="https://www.uraimo.com/2019/04/11/A-long-overdue-update-on-Swift-5-0-for-raspberry-pi-zero-1-2-3/"><strong>Umberto Raimondi</strong></a><strong> blog. Once I will have more time, I will update this post with new information.</strong></p><p>Recently I became interested in writing software that would interface with external hardware devices like sensors or motors. One of the easiest ways to interact with external hardware is through a <a href="https://www.raspberrypi.org/">Raspberry Pi</a>. The small computer has 40 GPIO pins that will let you connect it to external devices. About a month ago I bought a Raspberry Pi to see what I can do with it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A8YtBzAztFcFI9hLa2tP6g.jpeg" /><figcaption>Photo from raspberrypi.org</figcaption></figure><p>By day, I am an iOS developer, developing mobile apps for startups. Most of the apps I create nowadays are written in the <a href="https://swift.org/">Swift</a> programming language.</p><p>I love Swift. The new Apple language is modern, safe and expressive. While the speed of development may not be on par with a scripting language such as Python, the static type system makes the overall application more safe and robust. Since I am very well versed in Swift, I wanted to explore its support for the Pi. Here is what I found so far.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SJpE8gUfLFHTJtGKat_BDA.png" /><figcaption>Swift logo taken from apple.com, Raspberry Pi logo from raspberrypi.org</figcaption></figure><p>There are two main components needed to write Swift on the Raspberry Pi:</p><ul><li>A Swift compiler and package manager for the platform</li><li>A Swift library for GPIO support</li></ul><p>Although Apple does publish <a href="https://swift.org/download/#snapshots">precompiled Swift binaries</a> with support for Linux, it only supports platforms with x86 processors. There is no official support for ARM devices such as the Raspberry Pi. But Swift is open source and with the incredible work of some <a href="http://dev.iachieved.it/iachievedit/swift-3-0-on-raspberry-pi-2-and-3/">dedicated contributors</a>, the Swift compiler was ported to ARM systems.</p><p><a href="https://www.uraimo.com/">Umberto Raimondi</a> recently published <a href="https://www.uraimo.com/2016/12/30/Swift-3-0-2-for-raspberrypi-zero-1-2-3/">Swift 3.0.2 precompiled binaries</a> that work on the Pi. I had problems with the Raspbian version since the Package Manager was broken there. But once I installed Ubuntu Mate and then the Swift Ubuntu binaries everything was working fine.</p><p>Umberto is also the author of a <a href="https://github.com/uraimo/SwiftyGPIO">GPIO library</a> written in Swift. You can install the library using the Swift Package Manager.</p><p>Using the above infrastructure I was able to run my first Swift program to light up an LED using GPIO pins on the Raspberry Pi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jo7AzBu7-oEfmB2i5ScffA.jpeg" /><figcaption>Raspberry Pi running Swift code to light up a LED!</figcaption></figure><h4>Conclusion:</h4><p>Swift support on the Raspberry Pi is still very experimental and driven by a dedicated group of open source contributors. Hell, even Linux support is on a very early stage since the core libraries like Foundation are not fully ported to the OS. There is no IDE support, and at first, I was editing my programs in nano which was not a pleasant experience.</p><p>But Swift on the Pi is usable and if you want to play around, you should be able to set it up pretty quickly. Let’s hope Apple will one day officially support the ARM platform so we can deploy the full power of Swift with confidence!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f23445418ee2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>