<?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 Bruno Ramos on Medium]]></title>
        <description><![CDATA[Stories by Bruno Ramos on Medium]]></description>
        <link>https://medium.com/@bruno.hcr?source=rss-39314803b6c7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*0WhLqWCrP78UhVfGjMgCNQ.jpeg</url>
            <title>Stories by Bruno Ramos on Medium</title>
            <link>https://medium.com/@bruno.hcr?source=rss-39314803b6c7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 13:54:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bruno.hcr/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[Mastering Technical Debt: A Guide for Developers]]></title>
            <link>https://medium.com/@bruno.hcr/mastering-technical-debt-a-guide-for-developers-9d27eaf8b274?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d27eaf8b274</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Tue, 26 Mar 2024 20:47:12 GMT</pubDate>
            <atom:updated>2024-03-26T20:47:12.960Z</atom:updated>
            <content:encoded><![CDATA[<p>In the fast-paced world of software development, technical debt and code refactorings is an inevitable part of the process. However, not all technical debts are created equal, and knowing when to address them can be the difference between a project’s success and its stagnation. For developers navigating this challenging landscape, I’ve crafted a checklist based on my experiences and insights. This guide aims to empower developers to strategically prioritize technical debts in alignment with team, product and business goals.</p><h3>Understanding Technical Debt</h3><p>Before diving into prioritization, it’s crucial to understand the nature of the technical debt you’re dealing with. Ask yourself:</p><ol><li>What triggers the need to address this technical debt now?</li><li>Is it related to performance, scalability, security, or maintainability issues?</li><li>Have users experienced problems directly linked to this debt?</li></ol><p>Identifying the root causes and immediate impacts helps in quantifying the debt’s relevance and urgency.</p><h3>Assessing Impact and Expected Outcomes</h3><p>Next, evaluate the technical debt’s impact and the potential benefits of addressing it:</p><ol><li>How does this debt currently affect the product and development team?</li><li>What are the medium to long-term benefits of resolving it?</li><li>Is there a clear alignment between the proposed resolution and the product team’s expectations?</li></ol><p>Understanding these aspects ensures that efforts to address technical debts are justified and aligned with overall product strategy.</p><h3>Planning and Prioritization</h3><p>With a clear understanding of the technical debt, the next steps involve planning and prioritization:</p><ol><li>Is the debt well-documented, with a clear problem statement, proposed solution, and expected outcome?</li><li>Are there user stories, tasks, or spikes created for addressing this debt?</li><li>How does it stack up in priority against other planned features and tasks?</li></ol><p>Effective documentation and prioritization ensure that the team can make informed decisions about when and how to tackle technical debts.</p><h3>Execution and Monitoring</h3><p>The approach to addressing technical debt should be methodical and measurable:</p><ol><li>Can the resolution be broken down into smaller, incremental steps?</li><li>How will the success and impact of the resolution be measured?</li><li>Is there a plan for reviewing progress and addressing challenges during the resolution process?</li></ol><p>Breaking down the resolution process and setting clear metrics for success facilitate manageable and successful debt mitigation.</p><h3>Communication and Collaboration</h3><p>Clear communication and collaboration with stakeholders are vital:</p><ol><li>How have you communicated the importance of addressing this technical debt to stakeholders and the product team?</li><li>Is there a shared understanding among the development and product teams about the benefits of working on this debt?</li></ol><p>Ensuring everyone understands the value of addressing technical debts promotes support and collaboration across teams.</p><h3>Final Evaluation</h3><p>Finally, reassess the technical debt in light of the broader project and business goals:</p><ol><li>Will resolving this debt bring tangible benefits to end-users or the development team’s efficiency?</li><li>How does resolving this technical debt align with the project’s long-term goals and the company’s objectives?</li></ol><p>This final evaluation ensures that efforts invested in mitigating technical debt are impactful and contribute to the overarching goals of the project and organization.</p><p>By systematically evaluating technical debt using this checklist, iOS developers can make informed decisions that balance immediate project needs with long-term quality and sustainability. Addressing technical debt should not be seen as a detour but as an essential part of the journey towards building resilient, scalable, and user-friendly iOS applications.</p><p>This guide serves as a foundation for developers to negotiate and prioritize technical debts with product teams, ensuring that development efforts are always aligned with business objectives and user needs.</p><p>Concluding this exploration into managing technical debt, my journey over the past two years as a staff iOS SW engineer has profoundly shifted my perspective. Transitioning from a role steeped in technical complexities to one more intricately linked with product and business teams, I’ve realized a fundamental truth: the essence of our work extends far beyond code.</p><p>This realization isn’t merely about acknowledging the existence of technical debt or devising strategies to tackle it. Instead, it’s about embracing a holistic approach to software development — one that sees the engineer not just as a coder, but as a crucial bridge between the technical realm and the broader objectives of the product and business.</p><p>The transition has been enlightening, challenging me to rethink not only how we address technical debt but also how we can enhance our product testing methodologies. It’s about ensuring that our technical efforts are always in service of a superior user experience and the strategic goals of our business. This mindset shift — from a purely technical focus to a broader, product-oriented perspective — has been pivotal.</p><p>As engineers, our ultimate goal should be to translate the needs and objectives of our business and product teams into the architecture and features of our applications. This requires a deep understanding of the nuances of our business, an empathetic approach to product development, and a commitment to rigorous testing methodologies that ensure our products meet the highest standards of quality and reliability.</p><p>In essence, my experience has taught me that the most impactful work occurs when we break down the silos between engineering, product, and business. By fostering a culture of collaboration, continuous learning, and proactive engagement with the broader goals of our organization, we can create software that not only addresses immediate technical needs but also drives long-term success and innovation.</p><p>As we move forward, let us embrace this integrated approach, recognizing that our roles as developers are multifaceted. By aligning our technical expertise with the vision and objectives of our product and business teams, we can build not just better software, but better solutions that resonate with our users and contribute to the enduring success of our organizations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d27eaf8b274" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swift Test Tips and Tricks: Build a Well-Designed Test Structure]]></title>
            <link>https://medium.com/better-programming/swift-tests-tips-tricks-well-designed-test-structure-31dfa2fb5282?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/31dfa2fb5282</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Mon, 27 Jan 2020 00:31:51 GMT</pubDate>
            <atom:updated>2020-01-29T16:45:41.466Z</atom:updated>
            <content:encoded><![CDATA[<h4>What is Arrange-Act-Assert?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GDBxaLFilfgXAv4IyRFWTQ.png" /></figure><p>One of the principle ideas of this series is developing the mindset to write good test code discussing why it’s important. So let’s dive into a very nice way of writing tests.</p><p>In this piece, I want to talk a little bit about the Arrange-Act-Assert pattern. (You can find this concept referred to by other names as well, like Triple-A, Given-When-Then, or, the most known name, the AAA test pattern.) We’ll explain how we can implement this test-structure pattern in the Swift language.</p><p>Before I show you some examples, I really recommend you watch this WWDC session about engineering for testability presented in 2017. I believe this session is the biggest reason I’ve written all these pieces about tests — and it’s my main reference as well.</p><p><a href="https://developer.apple.com/videos/play/wwdc2017/414/">Engineering for Testability - WWDC 2017 - Videos - Apple Developer</a></p><h3>What&#39;s Arrange-Act-Assert?</h3><p>The Arrange-Act-Assert (AAA) pattern is a common way of writing unit tests for a method under test. I like to define it as a great guide for you to write and structure your tests better.</p><p>The best thing is it provides better readability for what your test is doing. When you read the structure of your test, you can give it a name consistent with your test. I’ll talk a little about nomenclature in this article, too — but it’s not the focus yet.</p><ul><li>The Arrange section of the unit-test method initializes objects and sets the value of the data that’s passed to the method under test.</li><li>The Act section invokes the method under test with the arranged parameters.</li><li>The Assert section verifies that the action of the method under test behaves as expected.</li></ul><p>So I’ll show you an example of how we can apply this pattern into our tests.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/145604e90c84fe6b87500a815855f02b/href">https://medium.com/media/145604e90c84fe6b87500a815855f02b/href</a></iframe><p>This is an example of a simple test. Basically, we want to validate if one category is valid.</p><p>Looking at this test, you can see it’s extensive, hard to read, and, if anything, needs to change or have some additional code put in. This test’s hard because the Arrange, Act, and validation of the test are all on a single line.</p><p>Let’s see the same test with a well-designed test structure, implementing the pattern:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d879a21dde7fbcbbbbd2fecba4a0e35d/href">https://medium.com/media/d879a21dde7fbcbbbbd2fecba4a0e35d/href</a></iframe><p>As you can see, the test is much better structured, well defined, easy to read and understand, and if for some reason something needs to change, it’s easy to do it.</p><p>You can choose to use comments to help you better understand your tests at the time you’re writing as I did in the example, or you can just try to follow the structure without comments.</p><h3>Final Notes</h3><p>This pattern is used in different programming languages, which can serve as a very nice guide used by your entire tech team and set a pattern for unit-test writing. This is also a great benefit, in my opinion — especially if your company has a well-defined code-review process where you can read tests in another language and understand the context and the writing of that test.</p><p>Hope you enjoyed it and it proves useful for your project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31dfa2fb5282" width="1" height="1" alt=""><hr><p><a href="https://medium.com/better-programming/swift-tests-tips-tricks-well-designed-test-structure-31dfa2fb5282">Swift Test Tips and Tricks: Build a Well-Designed Test Structure</a> was originally published in <a href="https://betterprogramming.pub/">Better Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swift Tests Tips & Tricks: Why shouldn't you use force unwrapping in your Test suite]]></title>
            <link>https://medium.com/@bruno.hcr/swift-tests-tips-tricks-why-shouldnt-you-use-force-unwrapping-in-your-test-suite-29c7e973a70b?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/29c7e973a70b</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Wed, 15 Jan 2020 03:30:15 GMT</pubDate>
            <atom:updated>2020-02-03T16:56:17.685Z</atom:updated>
            <content:encoded><![CDATA[<h3>Swift Tests Tips &amp; Tricks: Why shouldn&#39;t you use force unwrapping in your Test suite?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dqpDfCWeuwmtzfXWLo-X2w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OMcOcIacUJaAwVrBwPteFw.png" /></figure><p>First of all, I want to tell you one thing… Tests also should be written with a legible, organized and well design code! By the way, tests are code as well and you are writing tests for your amazing code, probably for you and your coworkers to read this in the future. So, above all, you need to be careful with it.</p><h4>Optionals</h4><p><em>Optionals</em> are a powerful feature in Swift language that come to solve the problem of non-existing values. Is just a type in Swift language. <strong>Int</strong> and <strong>Int? </strong>(optional Int)<strong> </strong>are two different types, if your variable happens to be of type <strong>Int</strong> you can be absolutely sure it will always have an integer value, and if your variable is of type <strong>Int? </strong>it will either have an integer value or it will have no value at all (in other words, it will be <strong>nil</strong>).</p><h4>Force unwrapping</h4><p>Basically <em>force unwrapping</em> can be defined as the action of <strong>extracting</strong> the value contained inside an Optional. But this operation is dangerous because you are telling the compiler <strong>this Optional value does contain a real value, extract it!</strong></p><p>It&#39;s very <strong>dangerous</strong> and <strong>unsafe</strong> to have this kind of action inside your co because different use cases are often very unpredictable because in a scenario you didn’t see, or even you didn’t want, thinking in a piece of code where you force unwrapping an optional value and it contains no value, your application will simply crash and not different from your application, this will also happen in your tests… In this article, I want to explain a little bit about this problem and how we can solve it.</p><h4>What happens when my tests got crashed?</h4><p>This is exactly what happens when your test suite got crashed:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x8KZO2n3j8T2k7-MOs2-PA.png" /></figure><p>You will receive an unreadable message, you will not know what test crashed, maybe you will know just what was the last test that ran, if it happens on Xcode, you are lucky to even know which line crash.</p><h4>What&#39;s the problems of that?</h4><p>If your team uses some continuous integration system when the machine is building some commit or pull request of your project. In the moment that it will run the process to validate your entire test suite, if some test crash, this process will break and stop with a fatal error message (???) Yup! Let’s start some discovery adventure to find what happens, what test failed and why it failed… Damage.</p><h3><strong>Alternatives to solve this</strong></h3><p>The examples I’ll show in this article, I want you to know are alternatives that I find very good and readable, which I use when I’m writing my tests but they are not the only solution that exists, but there are other alternatives inside swift language.</p><h4>XCTUnwrap()</h4><p>In <strong>swift 5.1</strong> Apple introduced a new <strong>method from XCTest framework </strong>XCTUnwrap() as a great solution when you need to assert and extract some content of an Optional value at same time and with little code.</p><p>Let&#39;s tale a look in the XCTUnwrap method:</p><pre>func XCTUnwrap&lt;T&gt;(_ expression: @autoclosure () throws -&gt; T?, _ message: @autoclosure () -&gt; <a href="https://developer.apple.com/documentation/swift/string">String</a> = &quot;&quot;, file: <a href="https://developer.apple.com/documentation/swift/staticstring">StaticString</a> = #file, line: <a href="https://developer.apple.com/documentation/swift/uint">UInt</a> = #line) throws -&gt; T</pre><p>Where <strong>expression</strong> of type T?. The expression’s type determines the type of the return value.</p><p>The <strong>message</strong> is an optional description of the failure.</p><p>The <strong>file</strong> in which the failure occurred. The default is the file name of the test case in which this function was called.</p><p>And the <strong>line</strong> number on which the failure occurred. The default is the line number on which this function was called.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bdc4f3fa686fdf603ca436befe6ee34c/href">https://medium.com/media/bdc4f3fa686fdf603ca436befe6ee34c/href</a></iframe><p>The first thing to note XCTUnwrap it’s a throwable method, so you need to change your test method to throwable as well, this way if this unwrap fails you can get an <em>Exception</em> localized message. In case that this test fails, we get the following message:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*c5r3_j9cFGZYtJj0BI90lA.png" /></figure><p>Is it very awesome, right? I really like this way to treat Optionals in swift tests, but as I mentioned earlier, this feature is available only for Swift 5.1 or higher.</p><h4>guard let</h4><p>I consider <em>guard let</em> a very nice alternative for XCTUnwrap for earlier versions of Swift 5.1, because as you treat unwraps in your code on early exits of your test method you can invoke some XCTFail() method passing a message like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/75862d81a8cc7283ebc5815f63e78376/href">https://medium.com/media/75862d81a8cc7283ebc5815f63e78376/href</a></iframe><p>The difference from XCTUnwrap is you&#39;re really treating the Optional value and you&#39;re causing a test fail manually and you&#39;re not receiving some throw exception how it works in the other example.</p><h4>XCTAssert Nullable methods</h4><p>Some <em>Assert</em> methods such XCTAssertNotEqual,XCTAssertEqual, XCTAssertNotNil, XCTAssertNil are nullable, that means you can compare optional values and don&#39;t be worry with strange test execution output, here is an example of a comparable test fail with nil value</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/836/1*XuC3ireOaXRnv1nfIsnthA.png" /></figure><p>This compiler message error from it’s very intuitive and legible, you can read this and understand that nil value is not equal 2. Or if you prefer, you can just pass a message param to show your own customized message if your test fails.</p><h4>Test Class Properties</h4><p>Some projects I worked, I remember it was very common<strong> some properties</strong> into test suite <strong>was declared as optional</strong> to receive an instance just in setUp() method, it because people thought that if we attribute an instance in the same moment we declared the property this would be shared the same instance allocated for all tests, generating<em> Flaky Tests </em>and in every test we wrote it was necessary to unwrap these optional properties, causing boilerplates…</p><p>But this is not true, because in <a href="https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/04-writing_tests.html">Writing Test Classes and Methods</a>; Apple Documentation says:</p><blockquote>For each test method, a new instance of the class is allocated and its instance setup method executed.</blockquote><p>As I said before, <strong>there are many other alternatives</strong> to treat or unwrap optional value in swift such as if let statement, use force unwrap in properties that really always will be non-nil (<em>view</em>, for example), setting default value for condition using ?? operator and others, the purpose of this article is to help you think that well-written test code is as important as your application code and should take care about it!</p><p>That’s all folks! I hope you enjoyed it and it is useful for your project. If you would like to give me feedback, ask questions, or discuss more about this topic, check me out on iOS Dev Br or iOS Folks slack team or <a href="http://twitter.com/bruno_hcr">@bruno_hcr</a> on Twitter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29c7e973a70b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Swift Tests Tips & Tricks: Fixture Object Pattern]]></title>
            <link>https://medium.com/@bruno.hcr/swift-tests-tips-tricks-fixture-object-pattern-5decefe6f10c?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/5decefe6f10c</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Mon, 13 Jan 2020 01:10:10 GMT</pubDate>
            <atom:updated>2020-01-31T17:06:54.573Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZzCVCUr8dAkbg38Y8x1KJQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RgCYIqYWzMP0HcuvdbLHMg.png" /></figure><p>In several projects, there are a lot of model dependencies into our classes and different layers, so it’s very common you need to create mocks, provide and inject these dependencies when you are writing unit tests to input values to the component inspected.</p><p>Fixtures is a pattern <strong>to make it easier to create new instances of an object</strong>. In different contexts, there are times when you need to test the behavior of a class that uses a state of an object, usually domain models, but this state is defined only by one property, I will use a status property in this article.</p><p>Think in a context that one object contains others objects as properties. When you are writing a test for a behavior that uses these properties, it’s difficult, boring and impracticable when you need to write a new instance of an entire object considering you only need one property variation to test that particular context. This is the problem Fixture proposes to solve.</p><p><strong>Creating a domain model</strong></p><p>Thinking we have a simple Photographer Profile model example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fbc6dc5ceff9424076afa9c408260d27/href">https://medium.com/media/fbc6dc5ceff9424076afa9c408260d27/href</a></iframe><p>Basically we have a photographer profile model that contains other different models PersonalInfo, Document and an enumerator Status.</p><p><strong>Testing with default memberwise initializer</strong></p><p>When you need to create a unit test of some class that depends of this Photographer object and you need to test a scenario, context or use case that uses Status property to change something, swift compiler force you to write the entire object because our model is a struct and we are using the compiler’s own initializer and wouldn’t it make much sense to override the init method just so we can write our tests with defaults on the main application target, right?</p><p>Let’s take a look at what a test would look like.</p><p>Imagine we have a view controller PhotographerViewController that contains the photographer’s status, and after we execute loadForm() method it loads the photographer’s info and fills in the information on the screen and its properties, and we want to validate if he received it right.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c15ed916f19b8436a0996d2d6563dbb1/href">https://medium.com/media/c15ed916f19b8436a0996d2d6563dbb1/href</a></iframe><h3>Fixture ease</h3><p>To keep tests shorter and easier to read, their content focused on acting and asserting the system under test, with little distraction in the setup stage, in this article I’ll introduce you Fixture Object Pattern, that has the purpose of helping us to do this in a simple way.</p><p>Since we are using these objects for testing, it makes a lot of sense to implement this pattern specifically and solely on our testing target.</p><p>So, in your test path classes structure, you can create a new path Fixtures, I really like to create a folder for each context I’m testing, but you can create as you see fit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*9EIYjl244IGRWmhHTViiJw.png" /></figure><p>This file contains the following code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/26749ae7198bcb54e0134bb0e7f879e3/href">https://medium.com/media/26749ae7198bcb54e0134bb0e7f879e3/href</a></iframe><p>Basically we are creating static methods using the fixture name which in their parameters receive all the necessary values to construct that struct containing default values.</p><p>Now objects that are properties within the Photographer object now also contain their default value as fixture(), so you don’t have to build the entire object with the default initializer.</p><p>Now with this implementation it’s much easier you write your object instance, just overwriting the properties that make sense and you want to test.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2278d26698b23a8c27676611c9bf56b7/href">https://medium.com/media/2278d26698b23a8c27676611c9bf56b7/href</a></iframe><p>It’s important that you pay attention to the default values you set in your fixtures so that they don’t change your test asserts, so always try to use nil, empty (“”), zero (0), and default case enums.</p><p>See that your test is now much more readable and you are preparing to set up your test with only what matters!</p><p>The cool thing is that, as a default, when you are writing some test after implementing Fixture, and the model does not contain a Fixture method, you will miss it a lot and will quickly write a Fixture for that model. In addition, using this technique is very simple if you need to use as a mock.</p><p>That’s all folks! I hope you enjoyed it and it is useful for your project. If you would like to give me feedback, ask questions, or discuss more about the topic, check me out on iOS Dev Br or iOS Folks slack team or @bruno_hcr on Twitter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5decefe6f10c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fastlane - Escrevendo seu Fastfile em Swift]]></title>
            <link>https://medium.com/@bruno.hcr/fastlane-escrevendo-seu-fastfile-em-swift-a78423305816?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/a78423305816</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[fastlane]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Wed, 23 Jan 2019 12:42:17 GMT</pubDate>
            <atom:updated>2019-01-23T19:51:17.118Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y-Ce7_i0-O7Cb3qHiIuxaw.png" /></figure><p>Nesse artigo gostaria de compartilhar minhas primeiras impressões em utilizar Swift e Xcode para escrever nossas lanes de automatização do nosso aplicativo iOS utilizando Fastlane.</p><p>A partir da versão 2.69.0 dessa maravilhosa ferramenta começou a oferecer suporte para a linguagem Swift, sendo assim desenvolvedores iOS não precisam mais escrever código Ruby para configurar o Fastlane em aplicações iOS ou MacOS.</p><p>Contextualizando um pouco… Fastlane é uma ferramenta que visa automatizar processos cotidianos de um desenvolvedor iOS, sendo algumas das principais: automatizar todo processo de code signing de um projeto, automatização de snapshots para AppStore, distribuição (Beta e AppStore) do aplicativo, rodar build e testes de sua aplicação, entre diversas outras possíveis facilitações que a ferramenta oferece. Se você já utilizou alguma ferramenta para auxiliar no desenvolvimento do seu app (danger, swift lint, crashlytics, jazzy, hockey app, testflight, sonarqube, etc), provavelmente o Fastlane oferece integração para ela, pois são mais de 400 integrações que a ferramenta oferece. Além de também oferecer integrações com grandes sistemas de CI para iOS, como <a href="https://travis-ci.org/">Travis CI</a>, <a href="https://jenkins.io/">Jenkins</a>, <a href="https://www.bitrise.io/">Bitrise CI</a> e <a href="https://circleci.com/">Circle CI</a>. Brincadeiras a parte, atualmente sou um grande evangelizador da ferramenta, então se você não conhece, recomendo fortemente que você acesse a página do <a href="https://fastlane.tools/">Fastlane</a> e implemente no seu projeto.</p><h3>Primeiros passos</h3><p>É possível encontrar toda a configuração do Fastlane em sua máquina na documentação da ferramenta nessa página… Nesse artigo, irei seguir passo a passo, e vocês verão como a configuração é feita de maneira simples.</p><p>Mesmo o Fastlane atualmente oferece suporte a linguagem Swift, ainda é um Rubygem, então é necessário instalar o Fastlane usando o Rubygem executando o seguinte comando:</p><pre>$ gem install fastlane</pre><p>Após a instalação é necessário somente verificarmos a versão instalada e garantir que a mesma é a partir da versão 2.69.0, que oferece suporte a linguagem swift, então execute o seguinte comando:</p><pre>$ fastlane -v</pre><p>Após verificado a versão, tudo pronto vamos começar o setup da ferramenta no nosso projeto.</p><h3>Configurando no projeto</h3><p>Se você já configurou Fastlane você deve saber como é simples a configuração no seu projeto iOS. Não é só porque vamos utilizar Swift que deve existir uma dificuldade maior para essa configuração, pelo contrário, a ideia é minimizar ao máximo o trabalho de um desenvolvedor iOS para começar a utilizar a ferramenta… Não é atoa que agora é possível fazermos todas as automatizações com a linguagem que temos familiaridade e poder utilizar o Xcode que é a mesma plataforma de desenvolvimento de nossas aplicações.</p><p>Tudo o que devemos fazer é rodar o seguinte comando na pasta raiz da sua aplicação iOS:</p><pre>$ fastlane init swift</pre><p>Pronto, você já realizou o setup do Fastlane em Swift na sua aplicação. A primeira mudança que podemos notar comparado a uma configuração padrão, é o swift na frente do comando.</p><p>Outra diferença nesse momento também é que ao invés de termos um Fastfile.rb localizado dentro da pasta fastlane, agora temos o seguinte arquivo:</p><pre>$ ./fastlane/swift/FastlaneRunner/FastlaneRunner.xcodeproj</pre><p>SIM! É um projeto do Xcode, e ele vai criar toda essa estrutura de forma automática pra você! Onde você vai poder fazer toda a configuração do Fastlane dentro desse projeto. Nesse momento você pode notar que o Fastlane criou 8 diretórios e 34 arquivos Swift dentro do diretório /fastlane, o que pode nos assustar um pouco, mas ainda há muita aventura, então não desanimem!</p><p>Também nesse momento temos os arquivos</p><pre>$ ./fastlane/Fastfile.swift<br>$ ./fastlane/Appfile.swift</pre><p>São nesses dois arquivos .swift que vou-lhes apresentar toda essa nova experiência!</p><p>Abrindo o arquivo do projeto nos deparamos com a seguinte estrutura de pastas e arquivos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*tw5Gr_1h8n6nmU7q2wMBpg.png" /></figure><p>Podemos ver que agora todas as configurações como Fastfile agora estão escritas na linguagem Swift. Agora podemos criar lanes usando os métodos da linguagem, todas as <a href="https://docs.fastlane.tools/actions/">actions</a> do Fastlane já estão disponíveis também.</p><p>Após realizadas algumas configurações nos dois arquivos. Nesse momento temos o seguinte código no nosso AppFile:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/660cd8eecba8d6e29e79c673e6e0d786/href">https://medium.com/media/660cd8eecba8d6e29e79c673e6e0d786/href</a></iframe><p>E no nosso Fastfile:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cffbf5f3e6fef28ce3a4b17ec78f3661/href">https://medium.com/media/cffbf5f3e6fef28ce3a4b17ec78f3661/href</a></iframe><p>Nos dois arquivos podemos fazer nossas observações sobre a implementação.</p><ol><li>Podemos perceber que nossa classe Fastfile faz herança com a class LaneFile, onde nos permite ter acesso a todos os métodos e propriedades que nos oferecem as integrações do Fastlane.</li><li>As suas lanes são declaradas através de métodos, é importante notar que é necessário ter a nomenclatura Lane no final da declaração do método.</li><li>Caso seja necessário receber algum valor na Lane, você deve declarar um dicionário como parâmetro do método e dentro dele você tratar conforme sua necessidade.</li><li>É possível você fazer o reaproveitamento entre as lanes, sendo assim, podemos quebrar as automatizações em pequenas lanes e reutiliza-las entre elas.</li><li>Todas as integrações e ferramentas do Fastlane estão disponíveis como métodos dentro da nossa classe e os parâmetros de cada método também estão disponíveis, não se tem a obrigação de informar todos, você pode fazer isso somente com os que você precisa.</li><li>CARACA JOVEM! ALÉM DE TUDO VOCÊ CONSEGUE DAR UM BUILD NO XCODE E VER SE O CÓDIGO ESTÁ TUDO BONITINHO E PRONTO PARA SER EXECUTADO!</li></ol><p>Com essas configurações realizadas, para executarmos nossas lanes, basta irmos no terminal e executarmos os seguintes comandos:</p><pre>$ fastlane test<br>$ fastlane beta<br>$ fastlane publishAppStore build_number:1 version_number:1.0</pre><p>Note que os parâmetros que você passar devem conter o mesmo nome que você definiu dentro do seu código como chave do dicionário.</p><p>Simples assim, já temos nossas primeiras lanes escritas em Swift dentro do Xcode! Mas lembre-se que esses são somente exemplos básicos, e que para que todas as <a href="https://docs.fastlane.tools/actions/">actions</a> de configuração de certificados e distribuição funcione de fato, deve ser feito todas as configurações no portal de desenvolvedor, acesso em máquina, configuração no repositório, projeto criado em uma ferramenta de distribuição beta, etc.</p><h3>Como isso funciona?</h3><p>Fastlane Swift é o wrapper Swift para executar comandos Ruby por baixo dos panos. Todas as opções de Scan, Match, Gym, Deliver são criadas usando os respectivos protocolos e extensões, onde todas as ações do Fastlane são colocadas em um gigante arquivo chamado Fastlane.swift que executa comandos do Ruby.</p><blockquote><strong>É importante lembrar que essa funcionalidade do Fastlane em Swift ainda é uma versão beta, sendo assim, não oferece suporte para inúmeros plugins que o Fastlane em sua configuração normal oferece, além de alguns outros problemas que você pode encontrar nessa nova jornada e que pode não existir alguma solução até o momento.</strong></blockquote><h3>Enjoy it!</h3><p>Vale notar alguns pontos positivos sobre tudo isso que foi apresentado nesse artigo!</p><ol><li>Todos os desenvolvedores de iOS podem agora entender facilmente o Fastlane, sendo assim os devs iOS da sua equipe não precisam mais estudar Ruby para configurar o Fastlane do seu projeto iOS.</li><li>O projeto Xcode oferece inúmeras facilidades na hora de configurar nossas lanes, como por exemplo, autocomplete, destaque de sintaxe para todas as ações Fastlane disponíveis.</li><li>O código é puramente em Swift, portanto, pode ser compilado e implementado facilmente.</li></ol><p>Os códigos apresentados nesse artigo estão disponíveis nesse <a href="https://github.com/bruno-hcr/fastlane-swift">repositório</a>.</p><p>Vou parando por aqui, espero que agora que você tem pelo menos uma idéia do que é Fastlane, para que serve e como funciona, que você consiga usufruir muito dessas automatizações e integrações!</p><p>Se você quiser dar um feedback desse artigo, tirar dúvidas ou discutir mais sobre o tema, me procure no slack iOS Dev Br, Bruno Ramos ou ‘bruno-hcr’.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a78423305816" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Participamos da try! Swift NYC 2018]]></title>
            <link>https://medium.com/@bruno.hcr/participamos-da-try-swift-nyc-2018-88351dea3e6a?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/88351dea3e6a</guid>
            <category><![CDATA[try-swift-nyc-2018]]></category>
            <category><![CDATA[ios-conference]]></category>
            <category><![CDATA[ios-community]]></category>
            <category><![CDATA[ios-development]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Wed, 19 Sep 2018 15:53:33 GMT</pubDate>
            <atom:updated>2018-09-19T16:50:51.878Z</atom:updated>
            <content:encoded><![CDATA[<p>Na última semana na cidade da Nova York aconteceu mais uma edição da try! Swift NYC 2018 que é uma conferencia organizada pela comunidade de desenvolvimento iOS, outras cidades em que se passa a conferencia é: San Jose e Tokyo. O objetivo principal do evento é trazer conteúdos de diversas empresas sobre a plataforma iOS, padrões de desenvolvimento, ferramentas e claro, workshop’s em que os desenvolvedores possam ter o seu primeiro contato ou aperfeiçoar seus conhecimentos sobre determinado assunto dentro da plataforma iOS. E quando eu digo, desenvolvedores, eu envolvo toda a comunidade mundial, participando e trabalhando para novos resultados na área. Para saber mais sobre a try! Swift, basta acessar o link:</p><p><a href="https://www.tryswift.co/">try! Swift Conference</a></p><p>Nesse ano tive a oportunidade de estar participando da minha primeira edição da conferência. Vou tentar contar um pouco como foi essa experiência sobre o evento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QByNoX1WtWb7pXRl0zwCOw.jpeg" /></figure><h3>A semana na try! Swift</h3><p>A try! Swift aconteceu nos dias 03, 04 e 05 do mês de setembro. Na mesma semana em que acontece a conferência, outros eventos são organizados pelos próprios desenvolvedores que moram ou trabalham na cidade de Nova York, sendo assim, o desenvolvimento, o networking e o compartilhamento de conhecimentos já começaram no sábado!</p><p>No sábado (01), aconteceu uma meetup &quot;Cocoapods peer lab&quot;, organizada por <a href="https://medium.com/u/2f838fbca107">Ash Furrow</a> e <a href="https://medium.com/u/d675eabc5bc7">orta</a> no escritório da <a href="https://medium.com/u/c937223d625d">Artsy</a>, com o propósito de juntar desenvolvedores iOS para compartilhar conhecimento, tirar dúvidas e conhecer novas pessoas 0/. Em particular, foi muito proveitoso para tirar dúvidas específicas de alguns casos que temos nos projetos da <a href="https://medium.com/u/49e71d6d13c3">Dextra</a>, onde pude conversar com os próprios criadores de determinadas ferramentas, ou pessoas que nos influenciaram em decisões sobre certas tecnologias, dúvidas foram esclarecidas e novas ideias surgiram a partir desse bate papo tecnológico!</p><p>Na segunda feira, tive a oportunidade de ser voluntário em um dos workshop&#39;s sobre acessibilidade para aplicativos iOS &quot;Making your app more accessible&quot; apresentado pelo <a href="https://twitter.com/BasThomas">Bas Broek</a>. Um conteúdo super interessante, sobre pontos e ferramentas que podemos utilizar dentro da própria plataforma de desenvolvimento para nos auxiliar em todo o processo de tornar nosso aplicativo mais acessível… Outro fator interessante também é saber como a “política” de acessibilidade em um aplicativo muda de acordo com a região que o mesmo oferece suporte! Acessibilidade é um tema atual e muito amplo, que se você não viu ainda, recomendo você pesquisar sobre, porque nós como desenvolvedores, temos a grande responsabilidade de não segregar os usuários dos nossos aplicativos, e sim dar suporte e assistência a qualquer pessoa que precise utliza-los.</p><p>Na terça feira (03), a conferência teve seu início.</p><p>Foram dois dias de evento (03 e 04), com diversos conteúdos, apresentações, palestras, sessões para tirar dúvida com os palestrantes, muito networking e compartilhamento de conhecimentos.</p><p>Vou tentar ser breve sobre em alguns conteúdos que mais me identifiquei nos dois dias de evento!</p><h4>Swift Server Side</h4><p>Você já pensou em fazer uma aplicação de servidor utilizando a linguagem Swift? Swift Server Side é um assunto que está abrindo novas portas para o desenvolvimento backend, e vou te contar que ela está vindo com tudo!</p><p>Quando falamos de Swift Server Side, é imprescindível não citarmos esses 3 frameworks, que nos dão suporte para o desenvolvimento. Que são os mais populares:</p><h4>Vapor</h4><p>O mais popular <em>Server Side Swift</em> framework até o momento.</p><p><a href="https://vapor.codes/">Vapor</a></p><h4>Perfect</h4><p>Primeiro e mais estável framework <em>Server Side Swift</em></p><p><a href="https://www.perfect.org/">Server-Side Swift is here: it&#39;s Perfect</a></p><h4>Kitura</h4><p>IBM também está presente no <em>Server Side Swift</em></p><p><a href="https://github.com/IBM-Swift/Kitura">IBM-Swift/Kitura</a></p><h4>Apple Machine Learning</h4><p>Na conferência, contamos com 3 grandes palestras sobre o Core ML, apresentados por <a href="https://medium.com/u/4a33a5464a76">mataharimau</a>, Aileen Nielsen e Kentaro Masumae, explicando um pouco sobre o framework de Machine Learning da Apple, onde mostraram exemplos do que é possível fazer com essa tecnologia.</p><p>O framework da Apple tem como objetivo ser prático e simples de ser utilizado dentro das nossas aplicações. Trazendo experiências incríveis para nossos usuários, oferecendo funcionalidades que tornam processos do cotidiano das pessoas muito mais fácil, divertido e intuitivo. Vimos que podemos utilizar o CoreML, para resolver problemas de download de consumo de banda de internet ao realizar download de imagens de um servidor por exemplo, onde é possível a gente utilizar o ferramenta de imagens, o Vision, para conseguirmos fazer o download de uma imagem de baixa resolução e aplicar uma &quot;super renderização&quot; para aumentarmos a qualidade da imagem a nível de aplicativo!</p><p>Imagine também que podemos realizar traduções de algum idioma em tempo real utilizando a câmera do nosso celular… Já pensou? A resposta para esse questionamento é: YES, WE CAN!</p><p>Esses são só alguns de exemplos que foram apresentados no evento. Para saber mais, explore um pouco os links abaixo, que explicam um pouco mais sobre a tecnologia.</p><ul><li><a href="https://developer.apple.com/machine-learning/">Machine Learning - Apple Developer</a></li><li><a href="https://developer.apple.com/documentation/createml">Create ML | Apple Developer Documentation</a></li></ul><h4>Swift Open Source</h4><p><a href="https://medium.com/u/c2c48dc19256">Daiki Matsudate</a> nos contou como é o processo de contribuir para a linguagem Swift, desde o momento que ele encontrou uma melhoria que deveria ser feita na linguagem Swift, até a aprovação de seu pull request no repositório do Swift.</p><p>Acredito que não tenha coisa mais gratificante do que contribuir para a linguagem que você desenvolve e cria suas aplicações…</p><p>No link abaixo você pode conhecer um pouco dessa jornada:</p><p><a href="https://swift.org/contributing/#contributing-code">Swift.org</a></p><h4><strong>Augmented Reality</strong></h4><p>Foi incrível ver como é simples criar soluções incríveis utilizando a ferramenta de realidade aumentada da Apple, o ARKit.</p><p>O ARKit é framework da Apple para aplicativos e jogos de realidade aumentada. Com essa tecnologia é possível transformar sua sala de estar no ambiente ou no mundo do aplicativo. Um olhar sobre o que é, pode nos dizer muito sobre que o futuro parece para realidade aumentada no iPhone e iPad.</p><p><a href="https://medium.com/u/b8fea2ef3b22">berta devant</a> deu um show ao vivo de como podemos utilizar o ARKit, mostrando como a ARKit usa as câmeras do iPhone para mapear um ambiente e fazer reconhecimento facial.</p><h4>Startup</h4><p>Com toda essas ferramentas em mãos, um pouco de estudo e esforço, temos mais o que o suficiente para arregaçar as mangas e investir em nosso próprio produto. Com uma ideia promissora, temos a visão de como um processo de crescimento de um negócio devem ter seus cuidados, paciência, capricho, preocupações, etc.</p><p><a href="https://medium.com/u/4966c8b1dc8f">Leah Culver</a> nos contou um pouco como foi sua jornada com Startup&#39;s e nos mostrou como seu aplicativo <a href="https://medium.com/u/e6241d150315">Breaker</a> se tornou uma grande referência no mercado de pod casts.</p><p>Além desses temas, vários outros foram abordados e apresentados… Desde de bons hábitos em nossas avaliações em pull requests, até mesmo de histórias inspiradoras e muito motivantes. Além de cases sobre desenvolvimento utilizando react native para soluções iOS, no qual temos ouvido falar muito atualmente, e como podemos explorar esse novo mundo para soluções mobile.</p><p>Todo o conteúdo das palestras, devem ser disponibilizadas em breve no link abaixo… Aproveite para conferir as edições anteriores e de outras cidades:</p><p><a href="https://www.youtube.com/channel/UCuPue-GLK4nVX8klxQITIOw">try! Swift Conference</a></p><p>A try! Swift tem em seu legado interação de pessoas, respeito à diversidade, respeito as pessoas, fazer novas amizades, aprender, ensinar, e dar a experiência para as pessoas de que todos são capazes e que todos temos muito a aprender, então particularmente, o evento tem os seus mais do que seus exemplares valores culturais, que são referência para outros tipos de conferências, eventos, etc.</p><p>Concluindo, a try! Swift sem sombra de dúvidas teve um conteúdo extremamente relevante para nossos projetos sobre ferramentas, práticas, novas tendências, incentivo, motivações e muito mais. Aproveitei a viagem para conhecer alguns “famosos” pontos turísticos da cidade! E caí entre nós… A cidade é extraordinária.</p><p>Sem dúvida, uma das melhores experiências da minha vida…</p><h3>Agradecimentos</h3><p>Os primeiros agradecimentos e merecidos parabéns para <a href="https://medium.com/u/902a4d56b584">NatashaTheRobot</a>, criadora e organizadora da conferência, pela incrível experiência direta que ela passa para os participantes do evento, além de todos os demais pontos que citei anteriormente.</p><p>Agradeço também a toda a equipe de organização e voluntários da try! Swift NYC 2018! Vocês fizeram um trabalho incrível! Parabéns pelo apoio e pelo empenho de cada um por fazer esse evento acontecer da melhor maneira possível!</p><p>Todo os devidos parabéns a todos os palestrantes da conferência, que conseguiram disseminar um conhecimento muito relevante para todas as pessoas… Além de toda a empatia, compreensão e receptividade nas sessões de Q&amp;A para tirar dúvidas.</p><p>Agradeço também ao <a href="https://medium.com/u/5d6459bb8222">Gustavo Barbosa</a> pela indicação do evento, amizade, hospedagem e também por ser meu guia durante toda a minha jornada na cidade de Nova York.</p><p>Agradeço a <a href="https://medium.com/u/49e71d6d13c3">Dextra</a> pelo incentivo, apoio, e toda a confiança por nosso trabalho!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88351dea3e6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatizando processos do seu projeto iOS com Integração Contínua]]></title>
            <link>https://medium.com/@bruno.hcr/automatizando-processos-do-seu-projeto-ios-com-integra%C3%A7%C3%A3o-cont%C3%ADnua-3f5a3dbb5ab6?source=rss-39314803b6c7------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f5a3dbb5ab6</guid>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[ios-ci]]></category>
            <category><![CDATA[automatização]]></category>
            <dc:creator><![CDATA[Bruno Ramos]]></dc:creator>
            <pubDate>Thu, 24 May 2018 20:27:28 GMT</pubDate>
            <atom:updated>2018-05-24T20:27:28.258Z</atom:updated>
            <content:encoded><![CDATA[<p>Você em algum momento já leu em algum lugar ou ouviu falar sobre Continuous Integration? CI? Integração contínua?</p><p>Ótimo, se você nunca ouviu falar, ou se você já ouviu e não sabe muito bem o que é, muito menos para o que serve, tenho uma dica para você! Leia esse artigo até o final, tenho certeza que você vai ficar muito impressionado com o que é possível fazer com essa prática de desenvolvimento de software incrível.</p><p>Nesse artigo, farei uma breve e resumida apresentação sobre o que é integração contínua, para que serve, como funcionam, vantagens de se utilizar, exemplos e dicas de algumas experiências (boas e ruins) que tive ao utilizar alguns sistemas de CI.</p><h3>O que é CI?</h3><p>Continuous Integration nada mais é do que uma prática de software na qual se tem a finalidade de resolver problemas de integração dentro de uma equipe de desenvolvimento de software, no caso desse artigo da nossa equipe de engenheiros iOS. Não somente com problemas de integrações de ferramentas propriamente ditas, mas também de problemas com a saúde de um projeto em desenvolvimento, onde existem várias pessoas, sendo elas, o estagiário, o desenvolvedor júnior que começou essa semana e está inseguro de realizar um commit e quebrar os testes e os demais que já são antigos no projeto e querem delegar a todos a responsabilidade de realizar um deploy do projeto.</p><p>Os sistemas de integração contínua, alguns deles podem ser configurados em uma máquina comum, ou servidores remotos e outros o próprio sistema já oferece uma máquina para ser configurada, e a mesma ficará olhando diretamente para nosso repositório remoto do sistema de versionamento (Git) onde está o nosso projeto, e tem a responsabilidade de executar um conjunto scripts (steps) que são delegados por nós engenheiros, de forma remota e automatizada.</p><h3>Para que serve CI?</h3><p>Como citado anteriormente, a prática tem como finalidade resolver problemas de integrações de uma equipe de desenvolvimento, automatizar processos e trazer inúmeras integrações com diversas ferramentas existentes no mercado atual. Calma que já vou explicar e dar exemplos!</p><p>Quando falamos sobre integração continua, acabamos abordando também o tema sobre entrega contínua, que diz… &quot;A partir do momento em que eu realizei um commit de um pacote para o meu aplicativo, e ele passar por todos os passos que foram definidos no sistema de CI, por exemplo, validação da build, validação dos testes unitários, for verificado a cobertura de testes, for realizado a validação de uma ferramenta de Lint e auto correct. Dessa forma eu garanto que meu pacote está pronto para ser enviado para produção&quot;. Com os sistemas de integração contínua é possível também automatizarmos os processos de liberação de uma versão beta do nosso aplicativo para a equipe de testes dentro da empresa, ou até mesmo fazer uma distribuição de uma nova versão do aplicativo para a App Store, sem que seja necessário fazer nenhum processo de forma manual e que você se sinta seguro de fazer essa distribuição.</p><h3>Como funciona CI?</h3><p>Em um sistema de CI, você desenvolvedor irá definir um conjunto de passos/processos que serão executados de forma automatizada e remota. Você também fará a configuração de quando esses workflows devem ser executados, ao realizar um push na master, por exemplo.</p><p>Já que tocamos nesse assunto, podemos fazer a configuração de realizar uma trigger (gatilho) de um determinado workflow quando realizarmos ações no repositório, como por exemplo, dar um push em determinada ou todas as branches, abrir um pull request de determinada ou todas para determinada ou todas as branches, ou até mesmo quando criarmos uma tag no nosso repositório.</p><p>Já podemos imaginar alguns processos bem definidos pensando nesses cenários e casos. Onde conseguiríamos definir padrões podendo criar planos de releases para o nosso aplicativo!</p><p>Acredito que a melhor forma de tentarm os entender e nos familiarizar com o assunto, é dando alguns exemplos!</p><p>Então vamos nessa…</p><p>Tudo começa quando falamos do casal perfeito, CI &amp; Fastlane. Então nesse exemplo, irei configurar a ferramenta de automatização Fastlane, para conseguirmos usufruir ainda mais de possíveis automatizações que conseguimos fazer da integração dessa ferramenta com um sistema de integração contínua.</p><p>Escolhi o sistema de CI <a href="https://circleci.com/">Circle CI</a> para fazermos a configuração de um novo projeto iOS, e também mostrar como fazemos automatizações de alguns processos comuns e rotineiros da nossa equipe de engenheiros.</p><ol><li>Vamos criar um repositório para nosso projeto. O link do projeto que vamos utilizar nesse artigo é esse <a href="https://github.com/bruno-hcr/continuousintegration-ios-example">AQUI</a>.</li><li>Agora vamos criar um projeto iOS</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*68gFmT1-zpOIbwqJ8CUMEQ.png" /></figure><p>3. Crie o projeto com Testes unitários e Testes de UI para validarmos no CI</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xq1q2mLkIT8KC6oinDIh6Q.png" /></figure><p>4. No exemplo, criei um método na nossa view controller para que possamos escrever um teste unitário</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0skLDTOHL1XJVEgG0v5wbQ.png" /></figure><p><em>Foi escrito um método que recebe dois valores do tipo Double e retorna esses dois valores somados.</em></p><p>5. Vamos escrever alguns testes unitários</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-lwRGwoWfklc2BPypPBfQ.png" /></figure><p><em>Foram escritos dois testes unitários simples que chamam o método criado em nossa View Controller e verifica os valores.</em></p><p><em>No primeiro teste &quot;testValidSumWithValidResult&quot; somamos dois valores e esperamos que ele nos retorne o valor correto, nesse caso foram somados os valores 4 e 4, e esperamos que ele retorne o valor final da soma que seria 8.</em></p><p><em>Já no segundo teste “testValidSumWithInvalidResult” somamos dois valores e esperamos que ele nos retorne o valor incorreto, nesse caso foram somados os valores 2 e 7, e esperamos que ele retorne o valor final da soma que seria 9.0. Porém no XCTAssert, repare que a condição é &quot;NotEqual&quot;.</em></p><p><em>Podemos verificar também que os testes já foram executados e estão válidos!</em></p><p>6. Também adicionei um componente na tela, para que possamos realizar um teste de tela</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*an3eGlOJxUit80lDANk8Mg.png" /></figure><p><em>Foram adicionados uma label &quot;Continuous Integration&quot; e um button &quot;Automating Everything&quot; os dois não possuem IBOutlets nem IBActions, só são componentes fixos na nossa View da nossa View Controller.</em></p><p>7. Vamos escrever alguns testes de tela</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8tHlfJQ8xBMr7QY2imlDsw.png" /></figure><p><em>Foi escrito um teste de tela, onde verificamos se os componentes que adicionamos em nossa View, se eles existem.</em></p><p><em>Podemos verificar também que os testes já foram executados e estão válidos!</em></p><p>8. Compartilhando o Scheme do projeto</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GioCh5PBVILGemaCYcKtpQ.png" /></figure><p><em>Clique no scheme do seu projeto ao lado do botão pausar build no xCode e clique em Manage Schemes, após isso, habilite a opção Shared do scheme que você irá rodar no sistema de CI. Isso deve ser feito para que o Fastlane consiga enxergar o scheme do seu projeto.</em></p><p>9. Agora vamos configurar o <a href="https://fastlane.tools/">Fastlane</a> no projeto</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*viFWFTCgCf4hnMKV5d4wBQ.gif" /></figure><p><em>Após rodarmos o comando &quot;fastlane init&quot; na pasta raiz do nosso projeto. Inicializamos o </em><a href="https://fastlane.tools/"><em>Fastlane</em></a><em> no nosso projeto e selecionamos a opção (4) de criarmos nossas lanes manualmente.</em></p><p>10. Vamos criar uma lane que rode nossa build, testes unitários e testes de tela</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fJ1Dmqwbzd9xX-hSIbNeSg.png" /></figure><p><em>Foi criado uma lane &quot;run_build_tests&quot; que irá executar o </em><a href="https://docs.fastlane.tools/actions/scan/"><em>Scan</em></a><em> do Fastlane. A lane irá validar nossa builds, testes unitários e testes de tela, antes de executar a validação ele irá dar um clean no projeto e obter o code coverage quando terminar de rodar os testes. É possível fazer configurações no </em><a href="https://docs.fastlane.tools/actions/scan/"><em>Scan</em></a><em>, como pular a etapa de validar build, rodar build e testes em um device ou sistema operacional específico, clean no projeto, etc.</em></p><p>11. Vamos configurar nosso repositório no nosso sistema de CI</p><p>Primeiramente, entre no site do Circle CI: <a href="https://circleci.com/">https://circleci.com/</a>.</p><p>Clique em Singn Up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jCi-ODOogL-umJgPmA-Iwg.png" /></figure><p>No exemplo, foi realizado o login com GitHub.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2eA0dqOrHfqY2cWoFcH_PA.png" /></figure><p>É necessário autorizar que o Circle CI tenha acesso ao seu cadastro do seu repositório, nesse caso no GitHub.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yf3eHVSR7IijkFrs4vMxRg.png" /></figure><p>A partir desse momento, já temos nosso cadastro dentro da plataforma do Circle CI. Agora já podemos adicionar nosso primeiro projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X6HTZ5cNqbORQvGcUDjAUQ.png" /></figure><p>Como você já deu o acesso da sua conta do GitHub, o sistema irá reconhecer os repositórios criados dentro do GitHub, então encontre e selecione o seu projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*453Ao8yz7AJ65BaBGqksxQ.png" /></figure><p>Selecione as configurações da máquina que irá rodar o seu projeto, nesse caso MacOs, e a linguagem utilizada em seu projeto, nesse exemplo, estamos utilizando Swift 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*20GVHA5nJhZmJ-KAhuTepg.png" /></figure><p>Nesse momento, já temos a configuração do nosso projeto dentro do nosso sistema de CI, e já temos nosso arquito .yml que contém as configurações manuais do projeto criado. Por padrão, o CircleCI cria um primeiro workflow, onde ele realiza a instalação do Cocoapods e roda a ferramenta Scan do Fastlane, essas configurações nós iremos alterar no próximo passo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0exqACv3GRtQqPS5mbK7TQ.png" /></figure><p>12. Vamos configurar nosso workflow</p><p>Nas configurações do workflow, é possível fazer toda configuração de ambiente, como configurar scripts que devem ser executados antes ou depois de rodar builds, testes, comandos que devem ser executados, no caso desse exemplo, rodar nossa lane que escrevemos acima, possível fazer configurações de notificações, chaves SSH, integrações, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Hr57_i32-eDMX6MSciuCg.png" /></figure><p><em>Foi configurado um script para executar a instalação do bundler em &quot;Pre-dependency&quot; que será executado antes do nosso script de validações.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oxj6loAwi5FBBG2hZaTltg.png" /></figure><p><em>Para o comando de validação de nossa build e testes, foi configurado a lane que escrevemos acima, como estamos utilizando o bundler, para garantir as versões das nossas dependências, utilizamos o comando &quot;bundle exec&quot; para executar o Fastlane.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UfNgbXGEbfy0C6g2cZRAiA.png" /></figure><p><em>É possível configurar integrações com ferramentas de chats, para que possamos sempre receber o report e logs das nossas builds que serão executadas e validadas em nosso sistema de CI.</em></p><p>13. Pronto! Nosso projeto já está rodando no nosso sistema de CI!</p><p>Todos os steps que foram configurados serão executados assim que o seu repositório receber uma atualização de uma nova versão do seu projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*09CKrctnipQDewFn99FupA.png" /></figure><p><em>É possível verificar que foi executado o comando para instalação do Bundler que configuramos nas pré dependências acima.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QqK3vAqSRoLZ01AkE49N3Q.png" /></figure><p><em>O nosso workflow irá executar a nossa lane para realizar a validação da nossa build, testes unitários e testes de tela. </em>Após toda a verificação, dando sucesso ou falha,<em> é possível fazermos a configuração para termos esse report e os logs via e-mail, slack, etc.</em></p><p>Pronto! Automatizamos um processo que normalmente realizamos em nossas máquinas a todo momento em nossa rotina de trabalho.</p><h3>O que eu ganhei? O que eu automatizei?</h3><p>Pff’ nada! Ou…</p><p>Quando seu time de engenheiros iOS utiliza um sistema de CI, é fácil identificarmos alguns ótimos benefícios que sua equipe usufrui…</p><p>Se vocês utilizam <a href="https://fastlane.tools/">Fastlane</a>… Ou… Se vocês utilizam <a href="https://fastlane.tools/">Fastlane</a> com <a href="http://bundler.io/">Bundler</a>… Perfeito! Vocês automatizaram tudo então! Mas vou listar alguns processos que automatizamos, para você não achar que estou contando história…</p><ul><li>Todos da equipe possuem confiança e se garantem do que foi entregue para produção.</li><li>Frases como “na minha máquina funciona” será extinto do seu time, pois ao utilizarmos um sistema de CI, vícios de ambientes são descartados em um primeiro momento, é de extrema importância fazer uma configuração de ponta de todas as dependências e ferramentas que seu projeto utiliza!</li><li>Independente da última pessoa que realizou um push, quando você baixar as alterações daquela pessoa, sua build e seus testes estão validados e passando!</li><li>Em um projeto open source, não é necessário verificar se um pull request está seguindo padrões do seu projeto, ou ter que rodar a build e os testes em sua máquina local…</li><li>Não é necessário parar o seu trabalho parar rodar build e testes.</li><li>Caso alguém faça alguma gambiarra no código, não foi necessário seu aplicativo ganhar um crash para verificar que o problema existe.</li><li>Você economizou horas (quem já trabalhou em um projeto que toda a distribuição beta e prod é realizada de forma manual, sabe o que eu to falando) ao ter que realizar um novo release do aplicativo.</li><li>Sua equipe de QA’s consegue escrever testes instrumentados e automatizados com mais confiança, e não precisam parar um engenheiro, caso o código dele não segue algum padrão do seu código.</li><li>É possível fazer uma configuração de feedbacks bem completos, de como seu projeto está e o que está acontecendo com ele na máquina ou servidor que está configurado o CI, através de e-mails, mensagens no slack, etc.</li></ul><h3>Sistemas de CI</h3><p>Existem no mercado hoje, várias soluções de sistemas de integração contínua, porém vou abordar e citar nesse artigo alguns, no qual já tive a experiência de conhecer e utilizar em diferentes cenários e projetos:</p><ul><li><a href="https://circleci.com/">Circle CI</a></li><li><a href="https://www.bitrise.io/">Bitrise</a></li><li><a href="https://www.buddybuild.com/">BuddyBuild</a></li><li><a href="https://travis-ci.org/">Travis CI</a></li></ul><p>Quando olhamos para diferentes soluções, é normal surgir a dúvida: “qual dos sistemas apresentados é o melhor?”. Tenho uma má notícia, não existe o melhor… Ou melhor, vou tentar melhorar minha explicação. Existe o melhor para o cenário do seu projeto, como ele é feito, qual a necessidade para o seu projeto, quais ferramentas e tecnologia o seu projeto utiliza, e quais as integrações que seu projeto e sua equipe necessita.</p><p>Pois, das soluções apresentadas acima, todas são soluções desenvolvidas para aplicações mobile, porém, cada uma apresenta suas peculiaridades, especialidades, Alguns oferecem planos atrativos (uns gratuitos, outros não), mas vale se questionar de todas essas variáveis antes de escolher qual o sistema de CI você vai utilizar para o projeto em que você atua!</p><h3>Lembre-se, nem tudo são flores</h3><p>Como tudo na vida, infelizmente nem tudo são flores, onde você vai conseguir automatizar tudo quanto é processo dentro de qualquer projeto. Lembre-se que, para um código mal escrito, qualquer melhoria se torna algo totalmente custoso!</p><p>Vale pensar também: qual é a sua finalidade em utilizar qualquer sistema de integração continua? Vou te ajudar a pensar um pouco.</p><ul><li>Se você trabalha em um projeto sozinho (no qual é um cenário bem comum, em grandes empresas e startups), e você quer resolver problemas de integração para validação de builds e testes. Talvez não faça muito sentido, pensando que esse problema normalmente é encontrado em uma equipe de desenvolvimento.</li><li>É estranhamente comum clientes não entenderem algum ganho ao implantar um sistema de CI, entendendo que é exigido um trabalho para configurar um ambiente decente, definir processos, criar workflows e delegar pessoas para dar manutenção nisso.</li><li>É importante que o prática do GitFlow esteja bem definida dentro do seu time… Caso contrário, será bem difícil estruturar seus Workflows e quando eles serão executados.</li><li>Em um projeto muito grande, pode acontecer que essa validação de todos os steps em um sistema de CI seja algo muito demorado.</li><li>Caso você trabalhe em um projeto totalmente legado, onde não existe nenhum tipo de padrão, nenhum teste unitário escrito para o projeto, você não consegue nem configurar o <a href="https://fastlane.tools/">Fastlane</a> no projeto, por ser totalmente inviável. Você não conseguiria aproveitar nada do que um sistema de integração contínua tem a oferecer.</li><li>A partir do momento que pensamos, que processos estarão rodando de forma remota, devemos pensar sobre como estruturaremos determinados processos para verificação de algum problema que acontecer em um dos passos definidos em um workflow. Por exemplo, caso na máquina aconteça algum problema no emulador do xCode, não teremos de forma clara o porque nossos testes de tela não foram executados, desde que na nossa máquina local está rodando perfeitamente. Então, pode ser que esses tipos de problemas tomem bastante tempo, até descobrirmos o que de fato pode estar acontecendo.</li></ul><h3>#FicaDica</h3><ul><li>Tenha uma prática de GitFlow decente no seu time, para se tornar mais ágil e menos custoso a definição de processos dentro do sistema de integração contínua.</li><li>Configure e utilize <a href="https://fastlane.tools/">Fastlane</a> para automatizar processos como, configuração de certificados no projeto, distribuição de versões beta e produção do aplicativo, validação da builds e testes, instalação de dependências, configurações de ambientes, etc.</li><li>Utilize <a href="http://bundler.io/">Bundler</a> com <a href="https://fastlane.tools/">Fastlane</a>, para você garantir que o sistema de CI e toda sua equipe de engenheiros iOS estão utilizando as mesmas versões das dependências do seu projeto.</li><li>Configure e utilize <a href="https://github.com/realm/SwiftLint">Swift Lint</a>, para definir padrões, regras e validações, para aumentar a qualidade de todo código do projeto.</li><li>Invista em workflows com bastante validações e integrações!</li><li>Usufrua ao máximo das integrações que seu sistema de CI oferece!</li><li>Utilize um sistema de CI que atenda sua necessidades, pois lembre-se: Não existe o melhor sistema de integração contínua! Mas sim, existe o melhor sistema de integração contínua para o seu contexto e para o seu projeto em específico!</li></ul><p>Vou parando por aqui, espero que agora que você tem pelo menos uma idéia do que é integração contínua, para que ela serve e como ela funciona, que você consiga usufruir muito dessas automatizações e integrações!</p><p>Caso queira saber mais, nesse link <a href="https://www.pscp.tv/w/1yNGakOlZMvxj">AQUI</a>, você pode assistir a apresentação de uma palestra muito bacana sobre integração contínua em projetos iOS.</p><p>Se você quiser dar um feedback desse artigo, tirar dúvidas ou discutir mais sobre o tema, me procure no slack iOS Dev Br, Bruno Ramos ou &#39;bruno-hcr&#39;.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f5a3dbb5ab6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>