<?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 Deyan Aleksandrov on Medium]]></title>
        <description><![CDATA[Stories by Deyan Aleksandrov on Medium]]></description>
        <link>https://medium.com/@didoaint?source=rss-f1ce655c1974------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VltxKsbV88y43hjFUSBs2A@2x.jpeg</url>
            <title>Stories by Deyan Aleksandrov on Medium</title>
            <link>https://medium.com/@didoaint?source=rss-f1ce655c1974------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 16:22:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@didoaint/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[Boost Your Software Team Productivity with AI-Driven PR Reviews: A Step-by-Step Guide]]></title>
            <link>https://medium.com/@didoaint/boost-your-software-team-productivity-with-ai-driven-pr-reviews-a-step-by-step-guide-659c61e27adb?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/659c61e27adb</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Sat, 03 Jan 2026 17:44:18 GMT</pubDate>
            <atom:updated>2026-01-04T16:40:14.244Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="UFOs waiting in a row at the DMV" src="https://cdn-images-1.medium.com/max/1024/1*wSF9-ixgh6VqOAUBgPJmXA.jpeg" /><figcaption>UFOs waiting in a row at the DMV</figcaption></figure><h4>Cut PR review cycles with AI and GitHub Copilot — fewer bottlenecks for engineering managers</h4><h3>Section 1: The Skepticism Paradox</h3><p>Here’s a paradox worth examining: <a href="http://github.blog/">GitHub’s 2025 Octoverse reports that 72.6% of developers using Copilot code review found it improved their effectiveness</a>.[¹] Yet Stack Overflow’s 2025 Developer Survey reveals that only <a href="https://survey.stackoverflow.co/2025/ai">33% of developers trust AI output accuracy — down from 43% the year before — with 46% now actively distrusting it</a>.[²]</p><p>Developers are using tools they trust <em>less</em> than they did a year ago.</p><p>This isn’t cognitive dissonance — it’s pragmatism. The value proposition has shifted. The conversation around AI in software development has largely focused on code generation: can AI write production-ready code?</p><p><strong>That framing misses where AI can deliver immediate, measurable value with far less trust required.</strong></p><h4>Verification vs. Judgment</h4><p>When I think about code review, I split it into two layers:</p><ul><li><strong>Judgment</strong>: architecture trade-offs, product intent, domain correctness, and long-term maintainability.</li><li><strong>Verification</strong>: consistency and completeness against <em>documented</em> standards — patterns, checklists, naming rules, analytics schemas, and “did we remember the boring but important stuff?”</li></ul><p>I don’t want AI making judgment calls for me. But I <em>do</em> want it relentlessly running the verification layer — because that’s the part humans agree matters, and still miss under deadline pressure.</p><p>PR review isn’t one thing. And skepticism about AI makes perfect sense when we ask it to architect systems or write business logic. But checking whether a PR follows established patterns? Whether analytics events include required parameters? Whether error handling matches conventions?</p><p><strong>That’s verification, not creation</strong>. <strong>And verification is where the bottleneck lives.</strong></p><p>Quality and productivity aren’t separate concerns — they’re linked through rework. Every analytics bug discovered three months post-release requires investigation, prioritization, a fix, another review cycle, and deployment. Fifteen seconds of AI verifying event parameters can prevent hours of future work.</p><p><strong>My bet:</strong></p><p>PR review verification is one of the fastest places for skeptical teams to <em>feel</em> AI’s value — because the output is auditable, and the risk is low.</p><h4>The blueprint in 30 seconds</h4><p>If you’re impatient, here’s what this article will show you:</p><ol><li>Add instruction files to your repo (your team’s actual patterns and rules)</li><li>Run AI review against your diff <em>before</em> opening the PR</li><li>Define severity levels so the AI doesn’t flood you with noise</li><li>Let humans focus on judgment, let AI handle verification</li><li>Iterate weekly and: add what it missed, remove what it nags about.</li></ol><p>The rest of this article explains why this works, what can go wrong, and how to measure whether it’s helping.</p><h3>Section 2: The Bottleneck Everyone Measures</h3><p>Code review is one of the most visible bottlenecks in software delivery. In organizations that track DORA-style delivery metrics, review time shows up quickly as “time-to-merge,” “time waiting for review,” and “review rounds.” <a href="https://www.faros.ai/blog/key-takeaways-from-the-dora-report-2025">DORA’s 2025 report found that despite AI boosting PRs merged by 98%, code review time <em>increased</em> by 91%</a> — a counterintuitive result suggesting AI generates more code faster than teams can absorb.[⁷]</p><p>The research on code review effectiveness is sobering. <a href="http://viewer.media.bitpipe.com/1253203751_753/1284482743_310/11_Best_Practices_for_Peer_Code_Review.pdf">A study from Cisco’s programming team</a> — often summarized in industry guidance from SmartBear — converges on what most teams learn through experience:[³]</p><ul><li><strong>200–400 lines of code</strong> is the optimal review size for defect detection</li><li>Review sessions longer than <strong>60 minutes</strong> show diminishing returns as reviewer attention degrades</li><li>Reviewers process approximately <strong>500 lines per hour</strong> effectively; beyond that, quality drops</li></ul><p>These aren’t arbitrary guidelines. They reflect cognitive limits. <strong>A 2,000-line PR isn’t just harder to review — it’s fundamentally incompatible with how human attention works</strong>. Yet large PRs are common because splitting work creates coordination overhead.</p><p>The bottleneck isn’t laziness or lack of process. It’s that thorough code review competes with the same cognitive resources needed for feature development. When a senior engineer spends two hours reviewing a PR, those are two hours not spent on architecture decisions, mentoring, or their own deliverables.</p><p>Organizations respond predictably aand review depth decreases as deadlines approach. The checks that slip first are exactly the ones AI handles well — style consistency, documentation completeness, pattern adherence.</p><p>There’s another factor I (unfortunately) rarely happen to discuss with colleagues — human reviewers aren’t consistent across authors. We review some colleagues more thoroughly than others. The senior engineer’s PR gets a quick approval while the new hire’s PR gets line-by-line scrutiny. These biases aren’t malicious — they’re human. But they mean the <em>same code</em> gets different verification depending on who wrote it.</p><p>This is where AI changes the equation — not by replacing human judgment on complex architectural decisions, but by taking on the verification layer humans consistently deprioritize under pressure — and applying it uniformly regardless of author.</p><h3>Section 3: The Blueprint — Structured AI Instructions (Quick Start Kit)</h3><p><strong>The difference between useful AI PR reviews and noise is structure</strong>. AI tools without context produce generic feedback — the equivalent of running a linter with default rules on a codebase with its own conventions.</p><p>This isn’t speculation. GitClear’s analysis of 153 million lines of code found that code churn hit <a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">7.9% in 2024 (up from 5.5% in 2020), with copy/paste code rising to 12.3%</a>.[⁵] The code patterns resembled work from <a href="https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality">“an itinerant contributor”</a> — someone unfamiliar with the codebase’s conventions, duplicating logic that already exists elsewhere.</p><p><a href="https://arxiv.org/abs/2302.06590">GitHub’s research on Copilot from <strong>2023</strong> showed a 55% speed improvement</a>.[⁶] However, the study did not examine the effects of AI on quality. It’s likely that increased speed without context led to <strong>quantity without quality</strong>. Developers probably spent time reviewing AI suggestions that went against architectural decisions, duplicated existing utilities, or introduced patterns the team had deliberately moved away from.</p><p>The lesson I learned? AI without understanding the codebase context doesn’t just fail to help — it actually creates more work.</p><h4>What this blueprint does NOT do</h4><p>To set expectations clearly:</p><ul><li><strong>No auto-merging</strong> — AI flags issues; humans decide what to do.</li><li><strong>No security sign-off</strong> — AI can check for obvious patterns (missing auth calls), but security review still needs human judgment.</li><li><strong>No reliable architecture decisions</strong> — AI might suggest using a repository pattern or how to structure your modules, but human judgment is necessary..</li><li><strong>No performance tuning</strong> — AI can flag obvious issues, but optimization requires context and execution AI doesn’t have.</li><li><strong>No replacing code review</strong> — This enhances human review, it doesn’t replace it.</li></ul><p>The goal is narrower — consistent verification of documented standards, freeing humans for the judgment calls that actually need them.</p><h4>Quick Start (30–60 minutes)</h4><p>If you want to try this without committing your team to “AI everywhere,” here’s the smallest version that works:</p><ol><li>Add a repo-wide instruction file (the rules you wish reviewers enforced consistently).</li><li>Add <em>one</em> path-specific instruction file for a high-value area (analytics is a great start).</li><li>Define severity levels so the AI doesn’t flood you with nits.</li><li>Run an AI review on your diff <em>before</em> opening the PR. It’s not necessary, but it’s good advice.</li><li>Iterate weekly — add what it missed, remove what it nags about.</li></ol><h4>The workflow I actually use (pre-flight, before humans)</h4><p>The most effective integration I’ve found isn’t AI reviewing PRs after they’re opened — it’s AI reviewing code before it reaches human reviewers at all.</p><ol><li>Write the feature</li><li>Push changes to a branch and open a PR</li><li>Run an AI review on the PR, either locally or on the server. Running it on the server keeps a history for future human reviewers, which I personally prefer to always have.</li><li>Fix what it catches</li><li><em>Then</em> submit the PR for human review</li></ol><p>This shifts AI review from “another reviewer in the queue” to a pre-flight checklist.</p><h4>What the AI catches</h4><p>With properly structured instructions, the AI reviewer enforces decisions the team has already made:</p><p><strong>Analytics completeness</strong>:</p><ul><li>Every user action requires tracking.</li><li>The instruction file lists required parameters per event type.</li><li>AI verifies every event includes screenName, userSegment, and action-specific context.</li><li>No more discovering missing attribution data three sprints later.</li></ul><p><strong>MVVM boundaries</strong>:</p><ul><li>ViewModels don’t import UIKit.</li><li>Views don’t contain business logic.</li><li>Coordinators handle navigation.</li><li>These aren’t suggestions — they’re structural decisions.</li><li>AI flags violations before they become patterns.</li></ul><p><strong>Protocol adoption</strong>:</p><ul><li>The codebase has established patterns for REST API integration — specific protocols for request building, response parsing, error handling.</li><li>A new endpoint that skips APIRequestConfigurable or handles errors inline instead of through APIErrorHandler gets flagged immediately.</li></ul><p><strong>Abstraction adherence</strong>:</p><ul><li>When the team decided all persistence goes through repository interfaces, that decision needs enforcement.</li><li>AI spots shortcuts when someone, whether it’s the new kid on the block or the project maverick, decides to query Core Data directly “just this once”.</li></ul><p><strong>The small things</strong>:</p><ul><li>Debug print statements.</li><li>TODO comments that should be tickets.</li><li>Force unwraps that should be guard statements.</li><li>Hardcoded strings that belong in localization files.</li><li>The reviewer <em>may</em> catch these, but why waste their attention on them?</li></ul><h4>Repository instructions (example: GitHub Copilot)</h4><p>GitHub Copilot supports two levels of instruction files:</p><p><strong>Repository-wide instructions</strong> (.github/<a href="http://copilot-instructions.md/">copilot-instructions.md</a>):</p><pre># Project Instructions<br><br>## Review split<br>- Verification tasks should be enforced consistently by AI.<br>- Judgment calls belong to humans.<br><br>## Architecture boundaries<br>- ViewModels should always be marked as @MainActor<br>- Coordinators handle navigation<br><br>## Concurrency<br>- All async operations use Swift Concurrency, not Combine<br><br>## Analytics<br>- Analytics events require both action and context parameters<br>- Do not ship debug logging or TODOs; convert TODOs to tickets<br><br>## Quality<br>- Prefer small PRs; if a PR exceeds ~400 lines, include a short review guide in the PR description</pre><p><strong>Path-specific instructions</strong> (.github/instructions/*.<a href="http://instructions.md/">instructions.md</a>):</p><pre>---<br>applyTo: &quot;Sources/Analytics/**&quot;<br>---<br><br># Analytics Module Instructions<br><br>## Event Naming<br>- Use dot-separated lowercase names (e.g., `article.read.completed`)<br>- Include `screen` context in all events<br><br>## Required Parameters<br>Every analytics event must include:<br>- `eventName`: The dot-separated event identifier<br>- `timestamp`: ISO 8601 format<br>- `sessionId`: Current session identifier<br></pre><p>To show this isn’t “just analytics,” here’s a second path-specific example (choose a module where you’ve been burned before):</p><pre>---<br>applyTo: &quot;Sources/Networking/**&quot;<br>---<br><br># Networking Module Instructions<br><br>## Consistency<br>- New endpoints must use the shared request builder and response decoder<br>- Do not parse JSON inline inside feature code<br><br>## Error handling<br>- Map transport errors into the shared error type<br>- Do not swallow errors; return typed failures and log at the boundary<br><br>## Testing<br>- Add unit tests for request encoding and response decoding when adding endpoints<br></pre><h4>Severity rubric (to prevent noise)</h4><p>If everything is “important,” the AI becomes background noise. You can use a simple rubric like this one:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MNso10fgDyD5yNJC1GDY7Q.png" /><figcaption>Severity rubric with examples</figcaption></figure><h4>What a good AI review comment looks like (output format)</h4><p>Here’s the structure I aim for (this is what I want posted as a review, or returned locally):</p><ul><li><strong>Summary</strong> (2–4 bullets)</li><li><strong>Findings by severity</strong> (Blocker → Low, could be percentages too)</li><li><strong>Suggested tests / QA scenarios</strong> (derived from actual diff)</li><li><strong>Needs human judgment</strong> (explicitly carve out trade-offs)</li></ul><p>Example:</p><pre>## AI Pre-Flight Review<br><br>### Summary<br>- Adds purchase flow completion tracking<br>- Refactors CheckoutViewModel concurrency to async/await<br><br>### Blockers<br>- None<br><br>### High<br>- Analytics event `checkout.purchase.completed` missing `currency`<br><br>### Medium<br>- ViewModel is not marked with @MainActor; move formatting helper into view layer<br><br>### Suggested QA<br>- Complete purchase with invalid promo code and verify analytics fires with full parameter set<br>- Cold start into checkout deep link<br><br>### Needs human judgment<br>- Is the new repository abstraction worth the extra indirection for this feature?</pre><h3>Section 4: Failure Modes &amp; Guardrails</h3><p>AI review is powerful precisely because it’s consistent — but consistency cuts both ways. Here’s what I’ve seen go wrong, and the guardrails that keep it useful.</p><h4>Failure modes</h4><ul><li><strong>Instruction drift</strong> — The AI enforces outdated rules that no longer apply. I find this very similar to when a team member follows outdated documentation.</li><li><strong>False positives → alert fatigue</strong> — People start ignoring what the bot writes.</li><li><strong>False negatives → false confidence</strong> — Teams assume “the bot didn’t complain” means “it’s correct.”</li><li><strong>Overreach into judgment</strong> — AI tries to dictate architecture instead of just highlighting risks. (I have not seen this happen to be honest, but it’s a potential risk)</li><li><strong>Security/privacy mistakes</strong> — Diffs may include secrets or sensitive data, and prompts might leak information. (Always be cautious about this)</li><li><strong>Social misuse</strong> — AI comments are used to judge engineer performance.</li></ul><h4>Guardrails</h4><ul><li><strong>Treat instruction files like code</strong> — assign an owner, review changes, and revisit quarterly in the least.</li><li><strong>Cap output</strong> — top N findings, group by severity, and link each finding to a specific rule.</li><li><strong>Make the split explicit!</strong> — <strong><em>AI verifies but humans judge</em>.</strong></li><li><strong>Audit occasionally</strong> — sample 1–2 in 10 PRs to estimate bot accuracy and tune rules.</li></ul><h3>Section 5: What AI Finds That Humans Miss (More in-depth)</h3><p>The value of AI PR reviews isn’t catching what humans would catch anyway — it’s catching what humans consistently deprioritize.</p><h4>Analytics implementation errors</h4><p>Analytics tracking is the canonical example. A missing parameter in an analytics event doesn’t break the build. It doesn’t cause runtime errors. It silently produces incomplete data that nobody notices until someone runs a report months later.</p><p>Human reviewers know analytics matters. They also know it’s boring to verify. Under time pressure, “analytics looks fine” becomes the default assessment.</p><p>AI doesn’t experience time pressure. Given instructions like “every purchase event must include productId, price, currency, and purchaseContext,” it verifies every event, every time.</p><h4>Documentation drift</h4><p>Documentation that doesn’t match code is worse than no documentation — it actively misleads. But keeping documentation synchronized requires noticing when code changes invalidate docs in other files.</p><p>Humans review changed files. AI can be instructed to check whether changes to a public API have corresponding documentation updates, whether removed parameters are still referenced, and whether examples still compile.</p><h4>Pattern adherence</h4><p>Every codebase accumulates patterns — some documented, many implicit. New team members don’t know them; experienced team members forget to check them during reviews.</p><p>AI, given explicit patterns, checks consistently.</p><h4>Access control verification</h4><p>Permission checks follow predictable patterns but fail in subtle ways. A new endpoint that forgets to verify ownership. A bulk operation that checks permissions on the first item but not subsequent ones.</p><p>Human reviewers catch these when they’re looking for them. AI, instructed with “every endpoint modifying user data must call verifyOwnership() before the operation,” checks every endpoint, every time.</p><h4>Edge-case handling</h4><p>Certain categories of bugs follow predictable patterns: off-by-one errors in pagination, timezone handling in date comparisons, null checks on optional chains.</p><p><strong><em>The meta-insight</em>: AI review doesn’t replace human judgment. It enforces documented judgment that humans apply inconsistently.</strong></p><h3>Section 6: How to Measure Whether It Worked</h3><p>If you want this to land with a mixed audience — ICs and leadership — you need a way to validate it beyond vibes.</p><h4>Metrics that will probably move first</h4><ul><li><strong>Time to first human review</strong> (does pre-flight reduce back-and-forth?)</li><li><strong>PR open → merge time</strong> (what is the improvement on average after 3 months?)</li><li><strong>Review rounds</strong> (how often does a PR bounce for “checklist stuff”?)</li><li><strong>Verification-class defects post-merge</strong> (analytics gaps, doc mismatches, missing permission checks)</li></ul><h4>Signals for ICs (quality of the bot itself)</h4><ul><li><strong>Acceptance rate</strong> (what % of AI findings lead to a code change?)</li><li><strong>Top recurring findings</strong> (the list that should become instruction updates)</li><li><strong>Human checklist comments trend</strong> (are humans spending less time on nits?)</li></ul><h4>A simple approach:</h4><ol><li>measure two weeks of baseline,</li><li>enable pre-flight AI verification,</li><li>then compare the next 2–4 weeks.</li><li>You’re not trying to prove a paper — you’re trying to see if your team is shipping with less rework.</li></ol><h3>Section 7: The Documentation Accelerator</h3><p>There’s a parallel to AI’s impact on code review in an unexpected domain: management consulting.</p><p><a href="https://mitsloan.mit.edu/ideas-made-to-matter/how-generative-ai-can-boost-highly-skilled-workers-productivity">A multi-school study of consultants using GPT-4 found a 40% performance increase on tasks within AI’s capability frontier — but a 19 percentage point <em>drop</em> when AI was applied outside its strengths.</a>[⁴] The researchers called this “jagged” value — dramatic gains in some areas, negative impact in others.</p><p>That “jagged frontier” maps cleanly onto PR review.</p><h4><strong>Senior engineers add unique value in:</strong></h4><ul><li><strong>Architectural judgment</strong> (“this approach will create scaling problems”)</li><li><strong>Domain knowledge</strong> (“this flow doesn’t match how our users behave”)</li><li><strong>Teaching moments</strong> (“here’s why we don’t do it that way”)</li></ul><h4><strong>They add less differentiated value in:</strong></h4><ul><li><strong>Style consistency verification</strong></li><li><strong>Checklist completion</strong> (tests present, docs updated, no debug code)</li><li><strong>Pattern matching against documented standards</strong></li></ul><h4><strong>AI handles the second category, freeing humans for the first.</strong></h4><p>The consulting comparison reveals something else — the teams that capture AI’s value aren’t the ones with the best tools but they’re the ones with the most explicit standards. A team with “our code should be high quality” gets nothing from AI. A team with documented conventions and named patterns can offload verification almost entirely — and the documentation improves reviews even without a bot.</p><h3>Section 8: Conclusion</h3><p>The bottleneck in code review isn’t going away. Codebases grow. Teams scale. Cognitive limits don’t change because we wish they would.</p><p>What changes is what we ask humans to do.</p><p>The shift isn’t “let AI review PRs.”<br>It’s: <strong>use AI for verification so humans can focus on judgment.</strong></p><p>Human reviewers bring bias — we review some colleagues more thoroughly than others, we’re influenced by past experiences with specific authors, we give different weight to the same patterns depending on who wrote them. AI reviewers bring different bias — they’re limited to what the instructions encode. They can’t catch (thought they might) what you didn’t think to document. They won’t recognize (thought they might) context that seems obvious to a human who’s been on the team for years.</p><p>This trade-off is the point. AI bias is explicit and auditable — it’s in the instruction file. Human bias is implicit and variable. For verification tasks with documented criteria, explicit bias wins. For judgment calls requiring context and nuance, human bias (with all its flaws) is still necessary.</p><p>That’s also why this is a great place for skeptical teams to start. The verification layer is explicit, auditable, and low-risk — and it pays back quickly in reduced rework.</p><p><strong>The blueprint is straightforward:</strong></p><ol><li><strong>Document your standards explicitly →</strong> If a convention exists only in senior engineers’ heads, AI can’t enforce it — and neither can anyone else consistently.</li><li><strong>Start with high-value, low-risk checks →</strong> Analytics, docs sync, access control patterns, boundary rules.</li><li><strong>Integrate with existing workflow →</strong> Pre-flight is the key — catch issues before humans see the PR.</li><li><strong>Iterate on instructions →</strong> Misses and noise are feedback. Update the instruction file like you update tests.</li></ol><p>The question isn’t whether AI can help with code review. It already can — today — for verification tasks.</p><p>The question is whether your team’s knowledge is documented well enough to leverage it. And if not, whether making it explicit is worth doing anyway.</p><h3>References</h3><p>[¹]: GitHub. “Octoverse 2025: AI leads developer activity.” GitHub Blog, 2025. <a href="https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/">https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/</a></p><p>[²]: Stack Overflow. “2025 Developer Survey: AI.” Stack Overflow, 2025. <a href="https://survey.stackoverflow.co/2025/ai">https://survey.stackoverflow.co/2025/ai</a></p><p>[³]: SmartBear. “11 Best Practices for Peer Code Review.” SmartBear Software, 2025. <a href="http://viewer.media.bitpipe.com/1253203751_753/1284482743_310/11_Best_Practices_for_Peer_Code_Review.pdf">http://viewer.media.bitpipe.com/1253203751_753/1284482743_310/11_Best_Practices_for_Peer_Code_Review.pdf</a></p><p>[⁴]: Dell’Acqua, F., et al. “Navigating the Jagged Technological Frontier: Field Experimental Evidence of the Effects of AI on Knowledge Worker Productivity and Quality.” Harvard Business School Working Paper 24–013, 2023. Summary: <a href="https://mitsloan.mit.edu/ideas-made-to-matter/how-generative-ai-can-boost-highly-skilled-workers-productivity">https://mitsloan.mit.edu/ideas-made-to-matter/how-generative-ai-can-boost-highly-skilled-workers-productivity</a></p><p>[⁵]: GitClear. “Coding on Copilot: 2023 Data Suggests Downward Pressure on Code Quality.” GitClear, January 2024. <a href="https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality">https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality</a> (2025 follow-up data confirms continued churn growth: <a href="https://www.gitclear.com/ai_assistant_code_quality_2025_research">https://www.gitclear.com/ai_assistant_code_quality_2025_research</a>)</p><p>[⁶]: Peng, S., Kalliamvakou, E., Cihon, P., Demirer, M. “The Impact of AI on Developer Productivity: Evidence from GitHub Copilot.” arXiv:2302.06590, February 2023. <a href="https://arxiv.org/abs/2302.06590">https://arxiv.org/abs/2302.06590</a></p><p>[⁷]: DORA. “DORA Report 2025: AI Impact on Developer Productivity.” Google Cloud, 2025. <a href="https://www.faros.ai/blog/key-takeaways-from-the-dora-report-2025">https://www.faros.ai/blog/key-takeaways-from-the-dora-report-2025</a></p><p>Originally published in <a href="https://groundctrl.dev/boost-your-software-team-productivity-with-ai-driven-pr-reviews-a-step-by-step-guide">https://groundctrl.dev/boost-your-software-team-productivity-with-ai-driven-pr-reviews-a-step-by-step-guide</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=659c61e27adb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built an App with Claude Code… But Claude Wasn’t the Point]]></title>
            <link>https://medium.com/@didoaint/i-built-an-app-with-claude-code-but-claude-wasnt-the-point-9540cda9a6e6?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/9540cda9a6e6</guid>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[api-integration]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[jira]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Sun, 28 Dec 2025 18:28:35 GMT</pubDate>
            <atom:updated>2026-01-02T12:15:12.955Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Hook</h3><p><strong>The irony</strong> wasn’t lost on me:</p><p>I used an AI coding assistant to create a dashboard that excludes the assistant for tasks that can run statically on the API alone, but includes the assistant for PR reviews when necessary.</p><p>A few days, a lot of prompts, and now <strong>255</strong> <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> <strong>issues</strong> later, I ended up with something more interesting (at least to me) than “just another AI wrapper”:</p><p><strong>The twist</strong>:<br>The more I leaned on Claude Code to build the app, the more I wanted the app itself to <em>NOT</em> lean on Claude Code. Wherever possible, I wanted plain APIs, local logic, and headless workflows that would keep working even if I swapped the AI out.</p><h3>The Original Pain: Too Many Tabs, Not Enough Flow</h3><p>My typical morning looked like this:</p><ul><li>Open Issue Tracker (e.g. Jira), check tickets assigned to me or to others.</li><li>Open Git Tracker (e.g. GitHub, GitLab), check PRs needing review.</li><li>Open CI/CD Service (e.g. Bitrise, GitLab CI), see what’s red or green, get a build out.</li><li>Open Messaging App (e.g. Teams, Slack), write a status update by hand …</li></ul><p>Each step is fine in isolation. Together, it’s a “18 tabs open and zero real flow” situation.</p><p>The obvious advice is to <em>just use an AI plugin/command inside Claude Code</em>. I do. Or <em>just use an AI plugin inside Jira</em>. I do that too.<br>They’re super useful. But they’re still trapped inside each tool, or they’re incomplete and they don’t give me:</p><ul><li>One place to see what’s ready to work on.</li><li>One place to see failing builds.</li><li>One place to see PRs that need attention.</li><li>One place where AI can help with reviews and summaries, without jumping between tabs.</li></ul><p><strong>So I built a small macOS cockpit for myself</strong>.</p><h3>Beads: The Issue System Behind It</h3><p>Before getting into the app, a quick nod to <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a>. I used my cockpit project as an excuse to properly test <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> for git‑native issues and dependency graphs with Claude Code, and I’m genuinely happy with it.</p><p>The numbers (255 issues, etc) above in the first section of the article are from that system. The dependency graphs and “ready to work” list made it much easier to ask a simple question: <em>“What should I do next?”</em> and get a straight answer.</p><p>I had originally planned a bigger comparison in this article between:</p><p>That deep dive can be its own article (and it will be). In <em>this</em> one, the important part is simpler: <strong>beads did its job well enough</strong> that I stopped thinking about my planning tool and focused on building the app.</p><h3>Building With Claude, But Not Around It</h3><p><strong>Claude Code still did all of the heavy lifting</strong>:</p><ul><li>Wiring API clients for all git tracking, ticket tracking and CI/CD services <em>because it knows them</em>.</li><li>Building the macOS UI and wiring it to those clients.</li><li>Generating issue templates, refactors, and <em>unit tests</em> ( <strong>512 of them so far</strong>).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ewEMPu1E1F-76l4E" /></figure><p>But every time I hit a design decision, I tried to ask:</p><blockquote><em>“Can this feature run without Claude? Can the app still be useful if I swap the AI provider or turn it off?”</em></blockquote><p>That question changed how I structured things.</p><h3>What the App Handles Directly</h3><p>Anywhere the standard APIs were enough, the app uses them directly:</p><ul><li><strong>Issue Tracker</strong> — saved queries, filters, and ticket details.</li><li><strong>Git Tracker</strong> — listing PRs, statuses, basic metadata.</li><li><strong>Build service</strong> — triggering builds where it makes sense.</li><li><strong>Local notifications</strong> — reminders for saved queries or conditions I care about.</li></ul><p>None of that requires AI to function. It’s simply a streamlined UI over APIs that I would otherwise use individually.</p><h3>Where AI Still Adds Real Leverage</h3><p>Then there are a few spots where AI really <em>does</em> change the experience:</p><ul><li>From the dashboard, I can select multiple PRs and trigger reviews.</li><li>Reviews run as background jobs.</li><li>Each one produces a structured summary with findings and checkboxes.</li><li>When I select what I agree with, the app posts a GitHub review from my account with the correct line‑level comments.</li></ul><p>This feels like the <strong>“killer feature”</strong>: I can run multiple reviews in parallel and then apply judgment, instead of reading every PR from scratch.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fdw3QNFCKr2w%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Ddw3QNFCKr2w&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fdw3QNFCKr2w%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ec5b426e9661b5971d77932d2b7ca3c1/href">https://medium.com/media/ec5b426e9661b5971d77932d2b7ca3c1/href</a></iframe><ul><li>Short, consistent summaries for status updates or messaging app posts.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YwRL5-dY4kAAA52z" /></figure><ul><li>For many cases, Apple’s local foundation models are enough (and free).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I576Wj9A2exRiIWM" /></figure><ul><li>For heavier contexts or trickier summaries, I can fall back to Claude or another provider.</li></ul><p>The design is “AI tiered by cost and capability”, not “everything through the most expensive model by default”.</p><p>So the AI is important-but it’s not the only brain. The app is built so that most of the value comes from the workflow and aggregation, not from one specific model.</p><h3>Living With AI Amnesia</h3><p>Of course, working with Claude Code itself wasn’t perfectly smooth. I set clear instructions like “<em>use the beads issue tracker for planning, not todos</em>”, and still had loops like:</p><pre>Claude: Let me create a todo list to track this... <br>Me: Use the issue tracker, not todos.<br>Claude: You&#39;re right, I&#39;ll create issues instead. [Later...] <br>Claude: I&#39;ll add this to the todo list...</pre><p>Some of that is context limits, some is built‑in prompts leaning toward native tools. The practical takeaways for me:</p><ul><li>You need <strong>constant reminders</strong> about your workflow — the CLAUDE.md file has instructions for using <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> but is not always respected.</li><li>You need <strong>short, explicit prompts</strong> like “Plan this as <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> issues” instead of hoping it remembers.</li><li>You need to <strong>accept that a bit of drift</strong> and correction is normal.</li></ul><p>Again, <a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> helped here — once issues existed in the repo and I reminded the bot to use them, they survived the AI’s memory lapses.</p><h3>A Quick Detour: Designing the Icon (And Failing Figma’s AI)</h3><p>Another fun side quest — <strong>the icon</strong>.</p><p>I’m not a designer, but I wanted something that felt at home next to Xcode, VS Code, etc. So I tried:</p><p>The results were… NOT fine. For me, Figma’s AI was useful as a brainstorming nudge, but not as “give me a final icon”. If it worked it would’ve been too easy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/0*UQn8KQjBWjWhglNO" /></figure><ul><li>What ended up working was using believe it or not, Perplexity!</li><li>A few iterations on a “control stand” / tower motif and I had something I can work it.</li><li>Iterating on colors and lighting.</li><li>A final touch-up through the Icon Composer macOS App, and I was all set.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eAh5gkCvsCaYUOKn" /></figure><p>That whole process could be its own short article: <em>“I tried to get Figma’s AI to design my app icon. It didn’t. Here’s what actually worked — Perplexity.”</em></p><p>For this story, it’s just another example of the same pattern:<br>AI can help, but the workflow and judgment still have to be yours.</p><h3>Notifications, Flags, and Keeping It Yours</h3><p>A few other parts that turned out surprisingly useful:</p><ul><li><strong>Local notifications</strong> — for saved queries or “watchlists”; easily testable from settings so you can check your notification logic without waiting a week.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yaXZq0jkzG88D0oN" /></figure><ul><li><strong>Feature flags</strong> — simple switches to hide integrations I’m not using at the moment. This keeps the cockpit focused instead of becoming a cluttered control panel.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q8DbJG6BSd0W6yGV" /></figure><p>None of this is technically complex, but together they make the app feel like <em>my</em> GroundCTRL cockpit, not just a generic dashboard.</p><h3>Takeaways</h3><p>From this round, the main lessons for me:</p><ul><li><strong>Using Claude Code to build an app is great, but the app shouldn’t depend on Claude Code to be useful.</strong></li><li><a href="https://github.com/steveyegge/beads"><strong>beads</strong></a> <strong>work well for multi‑session, dependency‑heavy work</strong> — good enough that I trust them as the planning backbone.</li><li><strong>APIs first, AI second</strong> — if Issue Tracker/Git Tracker/CI already give you the data you need, call them directly and save <strong>AI for summaries, PR reviews, and decision support</strong>.</li><li><strong>Headless AI PR reviews with a human in the loop feel like a real multiplier</strong> — let the model do the first pass, you decide what actually gets submitted.</li><li><strong>Design tools with AI are not magic</strong> — they can suggest directions, but for things like app icons you still need to drive.</li></ul><p>The bottleneck isn’t typing anymore. It’s orchestration — picking the right mix of APIs, local logic, and AI so that your tools match how you really work.</p><p><strong>And that’s what this little cockpit is for.</strong></p><p><em>Originally published at </em><a href="https://groundctrl.dev/i-built-an-app-with-claude-code-but-claude-wasnt-the-point">https://groundctrl.dev/i-built-an-app-with-claude-code-but-claude-wasnt-the-point</a> <em>on December 28, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9540cda9a6e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Maximize Efficiency with the 80/20 Rule]]></title>
            <link>https://medium.com/@didoaint/maximize-efficiency-with-the-80-20-rule-82a157f932cf?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/82a157f932cf</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[quick-reads]]></category>
            <category><![CDATA[pareto-principle]]></category>
            <category><![CDATA[productivity-tips]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Sat, 27 Dec 2025 18:16:43 GMT</pubDate>
            <atom:updated>2026-01-02T12:15:59.822Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IOMaquRcKUW8t_wU" /></figure><h3>Busy Work vs Real Impact in Engineering</h3><p>Most weeks, the work that drains the most energy is not the hard stuff. It’s the busy stuff.</p><p>All of that feels like progress.<br>The problem is that a lot of it barely moves the product or the team forward.</p><p>The Pareto principle (the 80/20 rule) says that a small share of effort typically produces a large share of results: <strong>roughly 20% of your work drives 80% of your outcomes</strong>. If that’s true, it also means something uncomfortable: a <strong>big chunk of your time is probably going into things that look like work, but don’t really change much</strong>.</p><h3>How busy work shows up for engineers</h3><p>In engineering, busy work often arrives disguised as “real work”:</p><p>On a board, these look legitimate. They’re real tasks, with estimates and assignees.<br>The cost isn’t that they’re totally useless. The cost is that they push more impactful work to “later”.</p><h3>Busy work as a starter task</h3><p>Busy work isn’t always the enemy. Sometimes it’s a useful on‑ramp. There are days when starting with a small, <strong>easy win</strong> is exactly what’s needed:</p><p>You get a quick success, your brain switches into “<strong>doing mode</strong>“, and suddenly the bigger, scarier task feels less heavy.</p><p><strong>The problem isn’t</strong> doing a bit of busy work.<br><strong>The problem is</strong> staying there-spending most of the week in low‑impact tasks and never coming back to the 20% of work that actually drives outcomes.</p><h3>Using 80/20 to avoid busy work</h3><p>The 80/20 rule is useful not just as a description, but as a filter.</p><p>If roughly 20% of your effort creates 80% of the impact, then your job is to find and protect that 20% as aggressively as possible. In practice, that means asking:</p><ul><li>Which few features, decisions, or fixes would actually change a user’s week?</li><li>Which conversations or decisions would unblock the most work for the team?</li></ul><p>A simple mental graph you can imagine:</p><ul><li>On the X‑axis: time spent.</li><li>On the Y‑axis: impact.</li><li>The first fifth of the graph shoots up quickly (20% of time → 80% of impact).</li><li>The remaining four‑fifths flatten out into a long tail-lots of effort, small gains.</li></ul><p>The goal is to spend more of your week in that steep early part of the curve, and less in the long, flat tail where busy work lives.</p><h3>The 80/20 version of tech debt</h3><p>Technical debt is the same story with different branding.</p><p>Taking on debt on purpose can be the right call. You ship a rough version, learn from real users, and then decide what’s worth cleaning up. But there’s also a version of tech debt where you spend weeks polishing things that don’t justify the investment.</p><p>Viewed through the 80/20 lens:</p><ul><li>The first 20% of effort gives you 80% of the value: a working feature in production, feedback from users, a clearer sense of what matters.</li><li>The last 80% of effort goes into chasing perfect abstractions, solving edge cases no one has hit yet, and rewriting code that already works “well enough”.</li></ul><p>Here, 80/20 helps with decisions:</p><ul><li>If a piece of debt is blocking that high‑impact 20% of work, pay it down early.</li><li>If it only affects the long tail of polish, log it, time‑box it, and tackle it later-if it’s still worth it.</li></ul><p>Sometimes that last 20% is truly important (compliance, safety, scalability).<br>Often it’s just comfortable busy work wearing a “quality” badge.</p><h3>Why busy work is so attractive</h3><p>There’s a reason this pattern is hard to break — busy work is emotionally easier:</p><p>High‑impact work is messier. You need to align people, make trade‑offs, and say “no” to things. You need to pick a direction without all the data. It feels riskier, so your brain quietly drags you back to the safe zone — another refactor, another small UI tweak, another “just in case” improvement.</p><h3>A simple heuristic: impact × reversibility</h3><p>A practical way to avoid getting stuck in busy work is to quickly score tasks on two axes:</p><ul><li><strong>Impact</strong> — If this goes well, who notices? Users, teams, the business, or just me?</li><li><strong>Reversibility</strong> — How hard is it to change or undo later if we get it wrong?</li></ul><p>Then roughly prioritise:</p><p>This doesn’t need to be a formal matrix. Even asking these questions in your head already filters out a lot of <strong>“because it annoys me”</strong> tasks.</p><h3>How this shows up in my own work</h3><p>In practice, this is what it looks like for me when working:</p><p>With a new feature, I often spend too much time on the final 10–20% of tasks, like deciding on the exact appearance of a button or the arrangement of multiple buttons. The core 80% of the work-the part that actually changes something for the user-is already done, but I get stuck perfecting minor details.</p><p>For example, I spent about four hours creating a solid first version of the app with the help of AI. On other days, I’ve lost almost the same amount of time debating button aesthetics and layout, which doesn’t really move the product forward.</p><p>As a manager, I can also sink hours into “perfect” documentation, trying to cover every possible scenario. A more impactful move is often a short recording or a simple checklist that unblocks the team quickly.</p><p>The pattern is the same — I drift into high‑effort, low‑impact work because it feels safer than making the next significant decision.</p><h3>Tactics to stay out of busy‑work mode</h3><p>A few things that help push back against this:</p><ul><li><strong>Start the day/week a clear plan for 2–3 outcomes</strong>, not a giant task list. “ <strong>Ship X</strong>”, “ <strong>Unblock Y</strong>”, “ <strong>Decide Z</strong> “ beats 20 micro‑tasks.</li><li><strong>Use busy work intentionally</strong> — one small task to warm up, then switch to a high‑impact item as soon as you have momentum.</li><li><strong>Time‑box polish</strong> — only a small percentage of the feature’s total time is allowed for refactors and tweaks; after that, it ships as‑is.</li><li><strong>Track intentional tech debt</strong> in one place and review it regularly, instead of trying to fix everything in the moment.</li><li><strong>Ask once a day</strong> “If I stopped working now, what changed for someone outside the team?”. If the answer is “not much,” you’re probably in busy‑work territory.</li></ul><p>The goal isn’t to ban busy work. It has its place as a warm‑up and as a finishing layer.<br>The goal is to keep most of your time in the 20% of work that actually bends the curve-and to use 80/20 as a simple lens for both avoiding busy work and deciding which tech debt really deserves your attention.</p><p><strong>Further reading</strong></p><ul><li>Pareto principle (80/20 rule) — Wikipedia <a href="https://en.wikipedia.org/wiki/Pareto_principle">https://en.wikipedia.org/wiki/Pareto_principle</a></li><li>Learn the Pareto Principle (Asana) <a href="https://asana.com/resources/pareto-principle-80-20-rule">https://asana.com/resources/pareto-principle-80-20-rule</a></li><li>The Pareto Principle: Reduce Your Workload with the 80/20 Rule <a href="https://openup.com/blog/pareto-principle/">https://openup.com/blog/pareto-principle/</a></li><li>When is the Right Time to Pay Down Tech Debt? <a href="https://madeintandem.com/blog/right-time-pay-tech-debt/">https://madeintandem.com/blog/right-time-pay-tech-debt/</a></li><li>Technical Debt: The Hidden Cost Of Shipping Fast And Thinking Later <a href="https://dev.to/alexindevs/technical-debt-the-hidden-cost-of-shipping-fast-and-thinking-later-587d">https://dev.to/alexindevs/technical-debt-the-hidden-cost-of-shipping-fast-and-thinking-later-587d</a></li></ul><p><em>Originally published at </em><a href="https://groundctrl.dev/breaking-free-from-busy-work-applying-the-8020-rule-in-engineering">https://groundctrl.dev/breaking-free-from-busy-work-applying-the-8020-rule-in-engineering</a> <em>on December 27, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82a157f932cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scratching the Firebase services with your iOS app]]></title>
            <link>https://medium.com/@didoaint/scratching-the-firebase-services-with-your-ios-app-c2746881c6d8?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2746881c6d8</guid>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Thu, 12 Apr 2018 09:27:47 GMT</pubDate>
            <atom:updated>2019-06-18T16:58:32.825Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YLC8I__Q1PCtvP6DFPdMdw.png" /></figure><p>It was one of those sunny days, when I was back home and finally had the time to plan the foodie app from my bucket list. For better or worse, it was not only the app design that I needed to work on but also:</p><ul><li>Authentication.</li><li>Database where I can save and retrieve stuff — data, info, images.</li><li>A searchable food API.</li></ul><p>Probably, I needed a serious someone to join my little team of just myself. Or, could I do it alone? More or less 😃. Short answer — yes! Because I found a decently priced searchable food API on one hand, and <strong>Firebase </strong>on the other. Long answer? Keep reading!</p><h3>But What is Firebase?</h3><p>Firebase is a unified platform for mobile developers (yes, both Android and iOS) that provides a whole bunch of awesome features some of which are Realtime Database, Crash Reporting, Analytics, Authentication and etc. It is best to check out the whole list at <a href="https://firebase.google.com/">their official website</a>.</p><h3><strong>Article Roadmap</strong></h3><p>The <a href="http://pxlme.me/8jZXQV0u">last article</a> I wrote included a project<strong><em> </em></strong>named Unicorner which was about receiving remote notifications with images of unicorns fellow Unicorner users saw and photographed. This time, the project will be about taking pictures of unicorns and uploading them to the database. The data from the database will then be fed to a list where the uploaded pictures and info can be seen. Notifications will not be sent but we can work on them in another article, right?</p><p>Anyways, this is the planned article workflow:</p><ul><li>Firebase account registration and iOS app configuration.</li><li>Setting up the Demo project in Xcode.</li><li>Write some code for communicating with the Firebase Realtime Database and Storage.</li></ul><h3>Setting up a Firebase Account</h3><p>This is quite simple actually. Go to this <a href="https://firebase.google.com/">link</a> first and then click the <strong>Sign In </strong>button at the top right of the screen. The sign-in can be done with a gmail account (<em>most people have one</em>) or by creating a new account following the registration steps.</p><p>When done, go to the Firebase Console by tapping <strong>Go To Console</strong>, on the top right again. And this is to be seen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9v-1IvM5dI6u3EadnfUMpA.png" /><figcaption>Welcome-to-Firebase Screen</figcaption></figure><p>I already have one app project that I am working on in my Firebase Console. To add another one, just tap <strong>Add project</strong> and see this modal come up:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KK8Lwi3DOPVrwiZplFs1Eg.png" /><figcaption>Add-a-Project Modal Screen</figcaption></figure><p>The name I have chosen for my project is <strong><em>UnicornUploader </em></strong>and<strong><em> </em></strong>the region I chose is US. Choose as you prefer, and then click <strong>Create Project</strong>.</p><p>Wait a bit while the project gets created and then, voila:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DnD3TCnx87lRhL-iXw7zkg.png" /><figcaption>Project-is-Ready Modal Screen</figcaption></figure><p>After tapping <strong>Continue</strong>, you will be taken to your <strong>Project Overview</strong> page:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0tmcW7qohsKOBU0eZDK4KA.png" /><figcaption>Project Overview Screen</figcaption></figure><p>This is the place where all the goodies that Firebase provides can be accessed. Indeed, in this article I am to focus on three only — Authentication, Database and Storage. You make sure to check them all out when the time allows.</p><h4>Add Firebase to iOS app</h4><p>Time to add Firebase to my iOS app by selecting <strong>Add Firebase to your iOS</strong> <strong>app</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PlxgXFa-KfJ2qlwt0sESCw.png" /><figcaption>Register-iOS-App Modal Screen</figcaption></figure><p>I have already put in the iOS Bundle ID of my demo project, you do the same for yours, and then tap <strong>Register App</strong>.</p><p>After some loading, Xcode instructions come up, better follow them! Download that <strong>GoogleService-Info.plist</strong> file and add it to the Xcode project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fER3BsTRyGEw8crsTYK1MQ.png" /><figcaption>Download-GoogleService-Info.plist-File Modal Screen</figcaption></figure><p>After tapping <strong>Continue</strong>, step 3 includes instructions on how to add Firebase to the project in the form of a Cocoapod dependency:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JplPtB2_DXUGLPCIrUaZhg.png" /><figcaption>Add-Firebase-SDK Modal Screen</figcaption></figure><p>No worries, if you are using my demo project, I have done the Cocoapod set-up for all the dependencies needed. Do make sure to use the <strong>.xcworkspace</strong> file though. Click <strong>Continue</strong> again and see the last step of the Firebase set-up:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*04EbYI6FsMFYlfBkFXFKyg.png" /><figcaption>Add-Initialization-Code Modal Screen</figcaption></figure><p>Do that if using your own project. If using mine, no worries, again, I have added the set-up configuration in the <strong>AppDelegate file</strong> too. Click <strong>Finish</strong> and see this not-so-interesting window showing project’s app info:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EfEE4FIqWYJrBo9SvpZkRQ.png" /><figcaption>Firebase-App-Activity Window</figcaption></figure><h4>Additional Firebase Configuration</h4><p>For the purpose of the demo project, there is a few things more that need being taken care of.</p><p>The first one is the <strong>Authentication Configuration</strong>. On the Firebase Console to the left, tap on <strong>Authentication</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*HUmZeVIlvjyGbFfEWsia9A.png" /><figcaption>Authentication Console Screen</figcaption></figure><p>You will then see this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3CYTAzxbAhXgvqhimbsQDg.png" /><figcaption>Set up Sign-In Method Screen</figcaption></figure><p>After clicking on the blue button, a whole list of <strong>Authentication Options</strong> is presented. Awesome!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hg4guW8xLA8elkAoq9Nipw.png" /><figcaption>Authentication Options Screenshot</figcaption></figure><p>For the purpose of simplicity, I am going to enable the <strong>Anonymous</strong> option only. Click <strong>Save </strong>and you are all-set for the demo project<strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*70m0DXTuKaR_IDsIQ3lVxA.png" /><figcaption>Enable Anonymous Guest Accounts Screenshot</figcaption></figure><p>Next thing that needs setting up is the <strong>Realtime Database</strong>. On the <strong>Firebase Console</strong> to the left, tap <strong>Database</strong> this time to see this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hwx5SbdIuojLRGKNFoyxMg.png" /><figcaption>Database-Get-Started Screen</figcaption></figure><p>Click the <strong>Get Started</strong> button for the <strong>Realtime Database</strong> cause that is the one needed for the demo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M_yHBxYqusCLLlCPcjLBPw.png" /><figcaption>Security Rules for the Realtime Database Screen</figcaption></figure><p>Before I enable the <strong>Realtime Database</strong>, I need to decide on the security rules. Well, for now I will choose the <strong>Start in test mode</strong> since I will only be testing. I can go ahead and click <strong>Enable</strong> and be done with the Database part for now.</p><p>Last but not least, I also need to enable the <strong>Firebase Storage</strong>. Again, on the <strong>Firebase Console</strong> to the left, tap on <strong>Storage</strong> this time and then tap on the <strong>Get Started</strong> button to see this modal window pop up:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FyblvHwI2L64I9V_jGL0_w.png" /><figcaption>Storage Default Security Rules Screen</figcaption></figure><p>You can see what the default security rules say — all writes and reads are allowed but when authenticated. So, change this piece of code:</p><pre>allow read, write: if request.auth != null;</pre><p>To allow for using the storage even when not authenticated:</p><pre>allow read, write: if request.auth == null;</pre><p>It is definitely counter-interactive, so make sure that is not how you handle authentication for a real app!</p><h4><strong>Working with the Firebase Realtime Database</strong></h4><p><strong>Firebase Realtime Database</strong> is actually quite easy to work. The first thing to do after configuring the <strong>Firebase connection</strong> in the <strong>AppDelegate</strong>, is to make sure that Firebase is imported within the VC in question, obviously 😃. Then, establish a connection to the database, or in Firebase words — define and create a reference to your database by defining a property first, like so:</p><pre>var ref: DatabaseReference!</pre><p>And then, in your <strong>viewDidLoad </strong>method, instantiate the <strong>DatabaseReference</strong> to the database’s root:</p><pre>ref = Database.database().reference()</pre><p>Easy, right? Lets add another record of a unicorn to a list of unicorns. There it is:</p><pre>ref.child(&quot;unicorns&quot;).child(&quot;Some unique ref id for unicorn&quot;).setValue(<br>[ &quot;addedBy&quot;: &quot;Tony&quot;,<br>  &quot;imagePath&quot;: &quot;Some image path&quot;,<br>  &quot;seenAt&quot;: &quot;Tokyo&quot;]<br>)</pre><p>What is done here is getting access to the “<strong><em>unicorns</em></strong>” reference in the database, then a unique reference for a unicorn is accessed, that is why a unique ID is needed. Uniqueness here helps avoid accidental overwriting. The <strong>setValue method</strong> is used to set the new value. Yeah, I have been saying “<strong><em>access a reference this and that</em></strong>” but it also means that if there is nothing to be accessed, it gets created. Sweet!</p><p>Then again, I have provided you with a super simple example. To see how it is all done the right away, do check out the official<a href="https://firebase.google.com/docs/database/ios/start"> Firebase Realtime Database Documentation</a>.</p><p>The other thing to pay attention to is structuring the data within the <strong>Firebase Realtime Database</strong>. You get to structure it like a JSON tree <strong>because</strong> all the data within is stored as JSON objects! The best instructions on how to do that can be found<a href="https://firebase.google.com/docs/database/ios/structure-data"> here</a>.</p><p>But what would the structure for the current demo app would look like?</p><p>Well, for the <strong>Unicorn</strong> model, there are three properties<strong> — addedBy, imagePath, seenAt</strong>. Therefore, this is how a JSON object for a a list of two Unicorn objects would look like:</p><pre>{<br>  &quot;unicorns&quot;: {<br>    &quot;unicorn1&quot;: {<br>      &quot;addedBy&quot;: &quot;Peter&quot;,<br>      &quot;imagePath&quot;: &quot;Some image path&quot;,<br>      &quot;seenAt&quot;: &quot;London&quot;<br>    },</pre><pre>    &quot;unicorn2&quot;: {<br>      &quot;addedBy&quot;: &quot;John&quot;,<br>      &quot;imagePath&quot;: &quot;Some image path&quot;, <br>      &quot;seenAt&quot;: &quot;New York&quot;<br>    }<br>  }<br>}</pre><h4>Working with the Firebase Storage</h4><p>Working with the <strong>Firebase Storage</strong> is quite similar and as easy. It all starts with a reference property:</p><pre>var storageRef: StorageReference!</pre><p>And in the <strong>viewDidLoad</strong> method, properly initialize the root <strong>StorageReference</strong>:</p><pre>storageRef = Storage.storage().reference()</pre><p>The <strong>storageRef</strong> can be used for a whole bunch of operations — create a reference to upload, download, or delete a file, etc. See<a href="https://firebase.google.com/docs/storage/ios/create-reference"> the official documentation</a> to check out all things possible. Within the demo project I will show how uploading and downloading an image is handled.</p><h3>Demo project</h3><p>Alright, let’s really get going. Since, I really want to concentrate on the Firebase part of this article, I have created a <a href="https://github.com/3257/unicorn-uploader">unicorn-uploaded starter project</a> on GitHub with everything needed preloaded. So, go ahead, download it and unarchive it. Make sure you are on the <strong>master branch</strong> because the starter project is there, the finished project is under the <strong>implemented branch</strong>. Also, be certain that you open <strong>unicornUploader.xcworkspace </strong>—<strong> </strong>it has the project with the needed Cocoapods installed already.</p><p>Next thing to do is to go ahead, build the project and take the time to check it out. It is quite simple actually, it only has two view controllers embedded in a navigation controller and a few special classes:</p><ul><li><strong>UnicornsTableViewController.swift</strong> — standard <strong>UITableViewController</strong> implementation, nothing special, to be populated with a list of all the uploaded unicorns.</li><li><strong>UploadUnicornViewController.swift</strong> — standard <strong>UIImagePickerController</strong> implementation that is left purposefully unfinished. You can click buttons but nothing happens. This is also the place to be used for sending records to the <strong>Firebase Realtime Database</strong>.</li><li>In the <strong>Models</strong> <strong>folder</strong>, there is a <strong>Unicorn.swift</strong> with a Unicorn class.</li><li>In the <strong>Cells folder</strong>, there is a <strong>UnicornTableViewCell.swift</strong> file that contains the custom class for the cell used in the table view in the <strong>UnicornsTableViewController.swift</strong>.</li></ul><h4>The Unicorn model</h4><p>I already showed you a simple way of writing to the database. What if the conversion of the model properties to JSON can be hidden? They can and writing to the database could look like this:</p><pre>ref.child(&quot;unicorns&quot;).child(&quot;Some unique ref id for unicorn&quot;).setValue(unicorn.toAnyObject())</pre><p>Official documentation says we can observe data like this(<em>adjusted for a single unicorn example</em>):</p><pre>ref.observe(.value) { (snapshot) in<br>  let unicorn = snapshot.value as? [String : AnyObject] ?? [:]<br>  // ...<br>}</pre><p>What if the conversion of the JSON to model properties can be hidden too? It can, and after tweaking the unicorn model do this instead of the above:</p><pre>ref.observe(.value) { (snapshot) in<br>  if let unicorn = Unicorn(snapshot: snapshot as? DataSnapshot) { <br>    // .... } <br>}</pre><p>To achieve both of above, the <strong>Unicorn</strong> model should be changed to this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/54183fff9bc0209613ea969a57379f42/href">https://medium.com/media/54183fff9bc0209613ea969a57379f42/href</a></iframe><h4>The UploadUnicornViewController class</h4><p>The first thing to do here is to get the references for the <strong>Realtime Database</strong> and for the <strong>Storage</strong>. Put these two lines before the picker property:</p><pre>fileprivate var ref: DatabaseReference!<br>fileprivate var storageRef: StorageReference!</pre><p>And then within the <strong>viewDidLoad</strong> method:</p><pre>ref = Database.database().reference()<br>storageRef = Storage.storage().reference()</pre><p>Alright, nothing too complicated so far! Still, before a new unicorn record is added to the <strong>Database</strong>, a unicorn’s image needs to be uploaded to the <strong>Storage</strong> first. The upload should allow for it to be easily cancelled if needed. No need unnecessary file taking space in the <strong>Storage</strong>! Therefore, let’s use a <strong>StorageUploadTask</strong> variable and put it below the reference properties:</p><pre>fileprivate var storageUploadTask: StorageUploadTask!</pre><p>One more property is needed named <strong>storageImagePath</strong> to keep track of the storage image path within the <strong>Storage</strong>.</p><pre>fileprivate var storageImagePath = “”</pre><p>Aaaand again, one more property is needed to help show and hide the network activity indicator:</p><pre>fileprivate var showNetworkActivityIndicator = false {<br>    didSet {<br>         UIApplication.shared.isNetworkActivityIndicatorVisible =              showNetworkActivityIndicator<br>   }<br>}</pre><p>Ok, time to make use of the <strong>Storage</strong> finally! Go to the<strong> imagePickerController(_:didFinishPickingMediaWithInfo:) </strong>method, the first method in the <strong>UploadUnicornViewController</strong> extension, delete it and replace it with this final implementation (<em>comments added for clarification</em>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fb742204a0935c6b096e2db0c6309900/href">https://medium.com/media/fb742204a0935c6b096e2db0c6309900/href</a></iframe><p>I think the implementation is quite straightforward — get the image picked, transform it to proper image data that can be handled by the <strong>Firebase Storage</strong>, give it a unique path to be accessed and proper content type and then upload it. The <strong>storageRef </strong>from before is used for the upload itself with the unique image path created — uniqueness is needed here again to avoid accidental overriding of images. The <strong>putData method </strong>works asynchronously to start the upload and actually returns a <strong>StorageUploadTask</strong> type which is assigned to the <strong>storageUploadTask </strong>property. The <strong>StorageUploadTask type</strong>, per documentation, in addition to starting uploads, can be used to pause, resume and cancel uploads. Then, the completion handler of the <strong>putData method</strong> either returns an error or a <strong>StorageMetadata </strong>object which can be safely ignored in the case but it does notify success.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F9M5dRSfRAZ1ucVXbww%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2F9M5dRSfRAZ1ucVXbww&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F9M5dRSfRAZ1ucVXbww%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="213" frameborder="0" scrolling="no"><a href="https://medium.com/media/caaf3a246c59b92df82c11481070aaa8/href">https://medium.com/media/caaf3a246c59b92df82c11481070aaa8/href</a></iframe><p>In the end of it all, call the <strong>uploadSuccess(_ storagePath:, _ storageImage:) </strong>method<strong> </strong>which looks like this on the inside:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/766ad187daf35e83e37ac405c0a4034b/href">https://medium.com/media/766ad187daf35e83e37ac405c0a4034b/href</a></iframe><p>First, set the image to the <strong>unicornImageView</strong>, update the <strong>storageImagePath</strong> property and enable the submit button (<em>which we disabled in the viewDidLoad method</em>). This completes the <strong>Firebase Storage</strong> uploading needed for the demo.</p><p>Moving on to recording a new unicorn to the <strong>Firebase Realtime Database</strong>, let’s first hook-up an outlet method for the submit button. I named mine <strong>didTapSubmit(_ sender:) </strong>and this is the code within it:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a1ed19f8be7759599174912c4cab6350/href">https://medium.com/media/a1ed19f8be7759599174912c4cab6350/href</a></iframe><p>Here, the rest of the properties for the unicorn object are taken first. Then, the function that will handle the writing to the database is called and passed the new unicorn instance. This is what the <strong>writeUnicornToDatabase(_ unicorn:)</strong> method looks like on the inside:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/43c07b30419c8bf61ee4c6762b9595a2/href">https://medium.com/media/43c07b30419c8bf61ee4c6762b9595a2/href</a></iframe><p>Pretty much the standard way of writing to the <strong>Firebase Realtime Database</strong> as discussed earlier. And again I used the same strategy for creating a unique reference as before — concatenating a unicorn property to the interval between 00:00:00 UTC on 1 January 2001 and the current date and time as an Integer.</p><p>Going back to the <strong>didTapSubmit(_ sender: UIButton) </strong>method, the last thing to be done there is pop the VC and go back to the initial VC when the new record of a unicorn is handled.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F1AeRkg7Uq8MV840d3e%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2F1AeRkg7Uq8MV840d3e&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F1AeRkg7Uq8MV840d3e%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="266" frameborder="0" scrolling="no"><a href="https://medium.com/media/cba05946afbdfe1a69741b10e865bb39/href">https://medium.com/media/cba05946afbdfe1a69741b10e865bb39/href</a></iframe><h4>The UnicornsTableViewController</h4><p>The plan here is only to get the recorded unicorns and show them in a table and it all starts with getting a reference property to the <strong>Database</strong>:</p><pre>var ref: DatabaseReference!</pre><p>And then in the <strong>viewDidLoad </strong>method:</p><pre>ref = Database.database().reference()</pre><p>Next thing to do is set the unicorns array variable with the unicorns from the database. That can be done in the <strong>viewWillAppear </strong>method<strong> </strong>like so:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8210a986ecb657fb81d76caff6c3396a/href">https://medium.com/media/8210a986ecb657fb81d76caff6c3396a/href</a></iframe><p>Per our initial set-up, each table view cell gets its unicorn object updated as well when this piece of code executes. So, yeah, few more things to be handled within the <strong>UnicornTableViewCell </strong>next.</p><h4>The UnicornTableViewCell</h4><p>Here, the <strong><em>addedBy and the seenAt labels </em></strong>are already configured to get updated when the unicorn object gets updated. What is left is to set the <strong>unicornImageView image</strong> with the correct image from the <strong>Firebase Storage</strong>.</p><p>And again, it all starts with the usual <strong>Firebase Storage </strong>set-up — a reference and a task (<em>a </em><strong><em>StorageDownload</em></strong><em> type this time</em>):</p><pre>var storageRef: StorageReference!<br>var storageDownloadTask: StorageDownloadTask!</pre><p>Next thing, initialise the <strong>storageRef</strong> in the kind-of-equivalent of a <strong>viewDidLoad </strong>method<strong> </strong>but for a <strong>UITableViewCell </strong>class — the<strong> awakeFromNib </strong>method<strong>, and </strong>add it before the <strong>prepareForReuse </strong>method:</p><pre>override func awakeFromNib() {<br>   super.awakeFromNib()<br>   storageRef = Storage.storage().reference()<br>}</pre><p>Talking about the <strong>prepareForReuse </strong>method<strong> </strong>— it is the best place to add this piece of code there to avoid unnecessary downloads from finishing:</p><pre>storageDownloadTask.cancel()</pre><p>And yes, I know, no attempts to download anything are executed yet, let alone cancel them. For that, I have prepared a nice method named <strong>downloadImage(from storageImagePath:) </strong>which obviously takes in one property and that is the path to the image. Put it in place of the last <strong>TODO:</strong> left from before in the <strong>didSet</strong> for the the <strong>unicorn </strong>property:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/34e71d08a96c79926ae7531b03f2f84b/href">https://medium.com/media/34e71d08a96c79926ae7531b03f2f84b/href</a></iframe><p>No worries, I did not forget, this is what the method looks on the inside, with relevant comments for clarification:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fb75f7bb78fec659260a9548a04efd1c/href">https://medium.com/media/fb75f7bb78fec659260a9548a04efd1c/href</a></iframe><p>And demo project is all set 🎊. Lets run it!</p><h4>Conclusion</h4><p>But before that, feel free to check out all that Firebase has put out there for us, developers. Also, explore the <a href="https://github.com/3257/unicorn-uploader/tree/implemented">completed project on GitHub</a> if you struggle with finishing it up following the article. And thank you! 🙇</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2746881c6d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS remote push notifications in a nutshell]]></title>
            <link>https://medium.com/@didoaint/ios-remote-push-notifications-in-a-nutshell-d05f5ccac252?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/d05f5ccac252</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Thu, 22 Feb 2018 13:38:44 GMT</pubDate>
            <atom:updated>2019-06-18T17:00:00.508Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N5S-XOXZwTQlVdO1ozeLkw.png" /></figure><h4><strong>What are remote Push Notifications?</strong></h4><p>Well if you ask the folks at Apple, they will probably direct you to this <a href="https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/APNSOverview.html">page on their website</a> where they describe notifications as follows:</p><blockquote><em>Apple Push Notification service</em> (APNs) is the centerpiece of the remote notifications feature. It is a robust, secure, and highly efficient service for app developers to propagate information to iOS (and, indirectly, watchOS), tvOS, and macOS devices.</blockquote><p>And I understand it as somewhat fancier words for just saying <strong>“This is how you remind users about the fact that they have your app installed on their phones”</strong>. I also see there: “Better make use of this robust feature, dude/lady!”. And this is exactly what we are going to do in this guide!</p><h4><strong>What can Push Notifications do?</strong></h4><blockquote>I am going to refer to Push Notifications as Push Notifications, PNs, APNs, Notifications, Remote Push Notifications, Remote Notifications and I will always have the same notion in mind.</blockquote><p>Here is what you can do with APNs these days:</p><ul><li>Display a message</li><li>Play a sound</li><li>Set a badge icon on your app</li><li>Provide actions the user can act upon with or without opening the app</li><li>Show an image or other type of media</li><li>Be silent but ask the app to perform some action in the background</li></ul><p>Way too many things probably but all useful. Still, as the title of the article goes, I am going to concentrate upon <strong>displaying messages, media and actions</strong>. Nobody likes a know-it-all anyways, right?</p><p>However, before seeing any of the APNs magic happen, there is some configuration to be done! It will help us protect our precious remote notifications from possible invaders — <strong>“<em>robust, secure, and highly efficient</em>”</strong> from the definition does sound scarier now but don’t you worry!</p><h4><strong>Stuff needed prepared Before APNS configuration can start</strong></h4><ul><li>A real iOS device. Simulators cannot receive notifications unfortunately. I am going to test things on <strong>iPhone 8 Plus with iOS 11</strong> on it.</li><li><strong>Apple Developer Program Membership </strong>— that is right, you need to finally pay what you have been avoiding to.</li><li>A way to send notification payloads to your device — a good way to do that is the simple to install and use <a href="https://github.com/noodlewerk/NWPusher">Pusher app</a> .</li></ul><h4><strong>APNS Configuration and initial step-by-step implementation</strong></h4><p><strong>Step 1, project set-up:</strong> Like anything else you are probably learning these days about iOS apps, it all starts with creating a project. That is right, mine is named <strong>Unicorner. </strong>The idea is simple — when a fellow unicorner user sees a unicorn and takes a picture of it, every user will receive that picture in a notification<strong>.</strong></p><p><strong>Step 2, enabling APNs: </strong>In Xcode, go to your <strong>Targets</strong>, under your <strong>app’s name, </strong>select<strong> Capabilities </strong>and find<strong> Push Notifications </strong>in the list<strong>, </strong>switch<strong> </strong>to<strong> ON</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*Ywx-Pw5oUojSpiRHnHPLCw.png" /><figcaption>Enable Push Notifications in Capabilities in Xcode</figcaption></figure><p><strong>Step 3, get APNs certificate: </strong>Go to your<a href="https://developer.apple.com/account/"> <strong>Apple Dev Member Center Account</strong></a> and log in. Click <strong>Certificates, IDs &amp; Profiles -&gt; Identifiers -&gt; App IDs </strong>where you should see all your app identifiers, select the one you are creating the notifications for. You will see a big list of <strong>Application Services</strong> available — <strong>Push Notifications</strong> should be marked as configurable:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*f2L4MWkMqY7mNj5AmJS7-w.png" /><figcaption>Push Notifications Configurable</figcaption></figure><p>There should be an <strong>Edit Button </strong>at the bottom, click it and find <strong>Push Notifications </strong>in that list again:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/845/1*9PE0cazcA3xRfp6QHUefFQ.png" /></figure><p>What you need is the <strong>Development SSL Certificate(<em>clarification regarding development vs. productions certificates provided at the end of the article</em>)</strong>, click on the <strong>Create Certificate Button</strong>, and follow the instructions to create a <strong>CSR File</strong>. In short, hold <strong>CMD + Space </strong>to start the spotlight search on your Mac, write <em>Keychain Access</em>, and press enter to launch the <strong>Keychain Access App</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*SwOtRhi2IbSHfhbOa0Rm0g.png" /><figcaption>Spotlight Search</figcaption></figure><p>Next step per Apple’s instructions:</p><blockquote>Within the Keychain Access drop down menu, select Keychain Access &gt; Certificate Assistant &gt; Request a Certificate from a Certificate Authority.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*PSz4aqhZclD6DVhbyV2DJQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/608/1*X_VjMfE43a8jgXSqGFIPsw.png" /><figcaption>Keychain Access dropdown on left and Certificate Information window on right</figcaption></figure><p>Properly fill in the Certificate Information and make sure you save the <strong>.certSigningRequest file</strong> at an easy-to-find place because then you need to upload it here:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*GyQBWv6lshFd3XNCsCThcA.png" /><figcaption>Upload CSR file screen</figcaption></figure><p>Do that. Then you will get this screen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/888/1*zIaI4Dn_fyH6oTRIg98iuQ.png" /><figcaption>Download .cer file screen</figcaption></figure><p>Download the generated <strong>Certificate</strong>, double-click the <em>.</em><strong><em>cer</em> file</strong> and find it it installed in your <strong>Keychain Access</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/668/1*DWDmNFl3JwfSDyU_hTAYaA.png" /></figure><p>This step was a long one but worth it. Follow these steps again <strong>Certificates, IDs &amp; Profiles -&gt; Identifiers -&gt; App IDs </strong>and you should see <strong>that Push Notifications</strong> are now enabled for <strong>Development</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*w2SA16f8r_-c8TRYRdexZA.png" /><figcaption>Developer Push Notifications enabled</figcaption></figure><p><strong>Step 4, some code finally: </strong>Lengthy configuration, I know, but as mentioned earlier, security is security. Time to code!</p><p>Go back to the project and open the <strong>AppDelegate.swift</strong> file. This is where we are going to ask the user for a permission to receive notifications from us before we try sending some 🦄.</p><p>On top of your <strong>AppDelegate.swift</strong> file, first:</p><pre>import UserNotifications</pre><p>Then within the AppDelegate class, add this function:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6c2931ee45571f2dbaae1274d5b55f55/href">https://medium.com/media/6c2931ee45571f2dbaae1274d5b55f55/href</a></iframe><p>Well, what is the code above actually doing? It is quite straightforward — we access the instance of the <strong>UserNotificationCenter</strong>, and then ask it to authorize us to send push notifications to the user in the form of alerts, sounds and badge app numbers. If granted, we call the <strong>registerForRemoteNotifications()</strong> function of the <strong>shared application</strong> instance on the main thread. We need to explicitly do it on the main thread or else, we would get the annoying error saying that we are calling the function on a background thread 😅.</p><p>Then we call <strong>registerForPushNotifications()</strong> function at the end of <strong>application(_:didFinishLaunchingWithOptions:) </strong>but before the <strong>return true</strong> statement, like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b3dc55a78cdc8c5319f86c970fca3372/href">https://medium.com/media/b3dc55a78cdc8c5319f86c970fca3372/href</a></iframe><p>In that way, we make sure the user is asked to register for push notifications at the start of the application. Run the project to see this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/307/1*AHqpMbMi7n8mbf8J8LXgYA.png" /><figcaption>Notification Authorization within App</figcaption></figure><p>The picture is quite self-explanatory, so, do press <strong>Allow</strong>, and voila, notifications will be received when sent! However, there is a pitfall to bear in mind in general — a user can always disallow push notifications authorization in the phone’s settings. <strong>We are not going to think about it now but such situation should be handled in a production app!</strong></p><p>Ok, lets continue. There’s two more delegate functions (<em>whose purpose is obvious I believe </em>— <em>one gets us the device token, the other one checks for errors if a</em>ny) to implement before we see any <strong>Push Notification</strong> action:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3bb5d009e70da4623151d25f529c36f/href">https://medium.com/media/a3bb5d009e70da4623151d25f529c36f/href</a></iframe><p>The code in the <strong>didRegister … function</strong> may seem weird at first but all it does is stringify the token for us so we can use it within the Pusher App.</p><p><strong>Step 5, sending a notification finally: </strong>Open Pusher after installing it:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/599/1*iZUMnU-8MFJtdGUUWWxX1Q.png" /><figcaption>Default start-up for Pusher</figcaption></figure><p>There is a drop-down menu where Pusher automatically detects what Push Certificates you already have in your Keychain Access. Click it and pick the one that corresponds to your app, like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/1*lZ1D5HX8FoHqH55TvpH3dg.png" /><figcaption>Example Push Certificate</figcaption></figure><p>Then in the next field, paste in your <strong>Device Token </strong>which you should see in the Xcode console on every start-up of your app when permission to send <strong>PNs</strong> is granted (<em>Please note that a device token may change when you delete and re-install the app on your device</em>). What I got for a token in my console is this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*cHjU3qmnwxNWlllNOBl3fg.png" /><figcaption>Example Device Token</figcaption></figure><p>Luckily, Pusher comes with a super-simple default payload which is just a JSON dictionary with specific Apple-defined keys (<em>no worries, they can be more than three</em>). What do Pusher’s given JSON keys mean?</p><ul><li>the <strong>alert</strong> key is going to display just a standart alert with a message saying “Testing ….”.</li><li>the <strong>badge</strong> key will just modify the badge of your app icon, this time to the number 1(<em>it can be any number, indeed</em>).</li><li>the <strong>sound</strong> key is quite obvious, the notification will just play the default sound.</li></ul><p>All right, the app is built and running on our real device, the needed certificate is added, the device token too, lets press the <strong>Push Button</strong> in <strong>Pusher</strong> and see some magic happen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*zIc4h8AVeNxqVS0JmtMi0Q.gif" /><figcaption>Testing simple notification</figcaption></figure><p>Yey, it works. Not very impressive because of no unicorns present. Eh, we will get there! (<em>If you want to know what a notification payload can carry, read</em><a href="https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/PayloadKeyReference.html"><em> here</em></a><em> and</em><a href="https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CreatingtheNotificationPayload.html#//apple_ref/doc/uid/TP40008194-CH10-SW1"><em> here</em></a><em>.</em>)</p><h4><strong>Adding media attachments</strong></h4><p>Well, well, we made it to actually sending a notification with some alert in it. Not bad but surely, most of us have received more sophisticated notifications (<em>pictures, gifs, etc.</em>), right? So, how to do that? I have two words for you — <strong>Service Extension</strong>. A <strong>Service Extension</strong> intercepts push payloads from apps, and gives you the chance to change content in the notification before it is presented.</p><p>As it is written on the <a href="https://developer.apple.com/app-extensions/">Apple website</a>:</p><blockquote>App extensions give users access to your app’s functionality and content throughout iOS and macOS.</blockquote><p>And that is what the <strong>Service Extension</strong> will do for us and our notifications — it will help us give users notifications with fancier appearance 🎊.</p><p>Enough jibber-jabber and more work! In Xcode, go to <strong>File-&gt;New-&gt;Target… </strong>like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*MEqh_mQ_Ut3WTIcjPOqzDQ.png" /><figcaption><strong>File-&gt;New-&gt;Target… </strong>selection</figcaption></figure><p>Then in the next menu, under <strong>iOS</strong>, <strong>Filter “s<em>ervice” </em></strong>and choose <strong>Notification Service Extension</strong> like so:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*x7Q_Vfx2hBZ1X6ID6ikyOw.png" /><figcaption>Filtering Notification Service Extension</figcaption></figure><p>Click the <strong>Next Button</strong> and give it a name of your choosing. I am going to name mine <strong>NotificationService</strong>. Click <strong>Finish</strong>. What we are going to get is a new group of two files created for us:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/254/1*trKKf3HmYrRbRU6kC-_BKA.png" /><figcaption>Notification Service file group</figcaption></figure><p>Go ahead and open the <strong>NotificationService.swift</strong> file. Do take the time to checkout the code written for us by Xcode. The <strong>didReceive(_:withContentHandler:) function</strong> is the one that is the more important because that is where we can modify the notification to our liking.</p><p>Before that, we need to go to our <strong>payload aps dictionary</strong> and make sure we add this key-value pair if we actually want to use a <strong><em>notification extension </em></strong>of any kind:</p><pre>  “mutable-content”:1</pre><p>It<strong><em> </em></strong>signifies that the OS should initiate the service extension of the app and do some extra processing.</p><p>The other thing that I will add to the payload now is an example unicorn image URL. I will imagine that someone took a picture of a unicorn and uploaded it to the server and that is why I, as a user, am getting notified. This is the final payload:</p><pre>{ <br>   &quot;aps&quot;: {<br>&quot;alert&quot;:&quot;Testing.. (0)&quot;,<br>&quot;badge&quot;:1,<br>&quot;sound&quot;:&quot;default&quot;,<br>&quot;mutable-content&quot;: 1,<br>&quot;attachment-url&quot;: &quot;<a href="https://tinyurl.com/y9exh3by">https://tinyurl.com/y9exh3by</a>&quot;<br>   }<br>}</pre><p>Now it is time to go back to the <strong>NotificationService.swift</strong> file and switch it up a bit. Apple team did provide some code ready for us but I would like to change it so that it handles the transformation of just a URL to an image attachment properly. For that I will need from this particular function (<em>comments added on the side so it makes sense a bit more</em>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d2d2acd0062d7f98044d2939c89599f/href">https://medium.com/media/3d2d2acd0062d7f98044d2939c89599f/href</a></iframe><p>Well, we do have the function that will do the magic for us. Well, let’s use it in the <a href="https://developer.apple.com/reference/usernotifications/unnotificationserviceextension/1648229-didreceive"><strong>didReceive(_:withContentHandler:)</strong></a><strong> method</strong>. This is what it should look like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7813f3da989c9261395cb132d798a8bc/href">https://medium.com/media/7813f3da989c9261395cb132d798a8bc/href</a></iframe><p>All these steps may seem magical at first so do take the time to make sure you understand them — all they do is just dig into the<strong> aps dictionary</strong> to extract the values. Then indeed, do test it to see a cool unicorn image show up in the notification 😏 🦄, like below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*CwwMFNTGDkckzrwjq1M5kw.gif" /><figcaption>Testing notification with image.</figcaption></figure><h4>Adding custom actions</h4><p>Well, good job till now I would say. Still, we want to make things even more fancier, like adding some custom actions? What I have in mind are a <strong>Like</strong> and a <strong>Save actions</strong> — for liking a picture and for saving a picture respectively.</p><p>Ok, go back to the <strong>NotificationService.swift</strong> file and between // 4. and // 5, add a // 6. like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f47145dcdeeab29be7e3d7b1546bcaa/href">https://medium.com/media/6f47145dcdeeab29be7e3d7b1546bcaa/href</a></iframe><p>All that is done here is creating the two actions wanted and adding them under a common category(<strong><em>“unicorning”, </em></strong><em>so original!</em>). That same common category will go in the <strong>aps Notification payload</strong> we send from Pusher. And that is how the <strong>Notification Service</strong> would know what notification actions to show! Simple, right?</p><p>Alright, try it out! If you do, you will see that when you use the force touch or pull down to see the bigger notification, you will see the custom actions show up there too, like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*2kPg0IGsngN5yzHBUf_Ufg.gif" /><figcaption>Testing notification with actions.</figcaption></figure><p>To be honest, we are not ready yet, because if you think about it, we are not handling these custom actions anywhere. The place to do that is in the <strong>AppDelegate.swift</strong> file. Just add this optional func before closing the <strong>AppDelegate</strong> class:</p><pre>func userNotificationCenter(_ center: <a href="/service/apple-reference-documentation://hsZ13BZPnJ">UNUserNotificationCenter</a>, didReceive response: <a href="/service/apple-reference-documentation://hs_yOEyymg">UNNotificationResponse</a>, withCompletionHandler completionHandler: @escaping () -&gt; <a href="/service/apple-reference-documentation://hsHG2idfN6">Void</a>)</pre><p>What it does is intercept the notification response for us. Within the response, we can check whether the user chose any of the custom actions provided and proceed with app logics based on that. The way I handled the actions, for demo purposes only, is just by printing out statements on the console, like so:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6e91b81be259883c89ad53229afa69e1/href">https://medium.com/media/6e91b81be259883c89ad53229afa69e1/href</a></iframe><p>Go ahead, test it out and see some not so fancy prints showing up on the console and the concept I am explaining proven! Indeed, in a real app, you would want to have some real and thoughtful logics happen when a user chooses your custom actions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*JJtRRBnRuJIzcXULnPyhaA.png" /><figcaption>Printing on the console.</figcaption></figure><h4><strong>Conclusion</strong></h4><p>After so much work done, probably it is best to go for a short conclusion, right? That is, I hope I not only helped you familiarize yourselves with APNs but also got you to put “<em>Digging deeper in the APNs and playing with some ideas</em>” topic on your bucket list! Because trust me, there is so much more to it 😃.</p><h4>Update providing additional clarification regarding APNs certificates</h4><p>I received some positive criticism pointing out that I was not clear enough when setting up the Unicorner demo app’s APNs certificates. And yes, I need to stress that when <strong>testing and building the app using Xcode, I used a development certificate</strong>. <strong>If you decide to release a beta version using TestFlight, or a production version in the AppStore, you need to use a production certificate and not a development one</strong>!</p><p>It is also worth mentioning that there is another way to set up your <strong>Push Notifications</strong> and that is using an <strong>APNs Auth Key</strong>. Doing that has two main benefits:</p><ul><li>No need to re-generate the push certificate every year.</li><li>One auth key can be used for all your apps — this avoids the complication of maintaining different certificates.</li></ul><p>If you think that an <strong>APNS Auth Key</strong> would work better for you, <a href="https://developer.clevertap.com/docs/how-to-create-an-ios-apns-auth-key">follow these easy set-up instructions</a>.</p><h4>Sources</h4><ul><li><a href="https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/APNSOverview.html#//apple_ref/doc/uid/TP40008194-CH8-SW1">Apple</a></li><li><a href="https://www.raywenderlich.com/156966/push-notifications-tutorial-getting-started">raywenderlich.com</a></li><li><a href="https://www.pluralsight.com/guides/swift/creating-ios-rich-push-notifications">Veronika on pluralsight.com</a></li><li><a href="https://pusher.com/tutorials/push-notifications-ios">pusher.com</a></li><li><a href="https://makeapppie.com/2017/01/09/actions-in-push-notifications/">makeapppie.com</a></li><li><a href="https://developer.clevertap.com/docs/how-to-create-an-ios-apns-auth-key">developer.clevertap.com</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d05f5ccac252" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The most obvious debug helper tool is the new screen recording feature]]></title>
            <link>https://medium.com/@didoaint/the-most-obvious-debug-helper-tool-is-the-new-screen-recording-feature-d77964b1a05?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/d77964b1a05</guid>
            <category><![CDATA[ios-11]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[apple]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Tue, 03 Oct 2017 21:06:38 GMT</pubDate>
            <atom:updated>2017-10-03T21:06:38.776Z</atom:updated>
            <content:encoded><![CDATA[<h4>Thank you iOS 11</h4><h4>Intro</h4><p>There it is, the beginning of October, I got my new iPhone 8 Plus, so yeah, I am not waiting for the X, since they are kind of the same in terms of features and all(<em>excluding the hardware design and the Face ID indeed 👊</em>). Still, it is a big change for me, I moved from regular size to plus size — hard to fit the phone in one hand but hey, that was the idea. What I need is something like an iPad but not the iPad all because I am too lazy to open my lap top when I want to watch YouTube 📺. Tough life I have, I know!</p><p>That is, however, not the most important thing I noticed while exploring my new phone. And what did I find, oh boy?! Initially it was all the stuff the Apple guys advertised and most people care about — the phone is really freaking fast, takes awesome pictures, the True Tone display is a great addition, the wireless charging, etc. But I am not a regular person, I am a developer!! And if you are developer too, you know what I mean — you consider how these new features are going to help you in your workday. And one particular feature I really cared for.</p><blockquote>Screen recording directly from the phone?! About time!</blockquote><p>No cables, no quickTime player, no nothing needed, just the phone. Think of the implications of that? I have a couple of examples</p><h4>A real-life example from work before iOS 11</h4><p>We started working on this app some months ago, we still are. It is an IoT app — some things get connected, data is passed over low-energy bluetooth, data is displayed. Cool stuff, right? We, the dev company, are situated in Europe while the guys that want the app made, who also act as the app testers most of the time, are in the USA. Also cool, right?</p><p>But there it happened, app testers started testing and we received some feedback regarding user experience, app crashes and app performance — the usual stuff we would care about. However, we generally need a structured report which is why we have this long list with instructions we give to app testers. They do what they do, they follow the list, and in turn we end up with another long list of instructions we would need to follow if we want to replicate anything.</p><blockquote>I did not enjoy that!</blockquote><h4><strong>A real-life example from work after iOS 11</strong></h4><p>Re-read that stuff about the app we work on and the app testing, etc. Now think about the screen recording feature. Nifty, right? All needed now is to ask the testers to update their phones to iOS 11 and show them how to record stuff with these steps:</p><p><strong><em>Step 1</em></strong>, go to <strong>Settings</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*FiCTZryvnhs5s5rpXp14HQ@2x.jpeg" /></figure><p><strong><em>Step 2</em></strong>, go to <strong>Control Center</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*XQqYtpOGpVxR8iP0kjscwQ@2x.jpeg" /></figure><p><strong><em>Step 3</em></strong>, go to <strong>Customize Controls</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*0EEB0b7dhJeG7HYWRMkJmA@2x.jpeg" /></figure><p><strong><em>Step 4</em></strong>, hit the green plus next to <strong>Screen Recording</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*zfSWHtvkQ4CGXPTxr5xKYw@2x.jpeg" /></figure><p><strong><em>Step 5</em></strong>, swipe up from screen bottom, and press the button for <strong>Screen Recording</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*eK2yxltEn4ktoRSFtmJMsw@2x.jpeg" /></figure><p><strong><em>3, 2, 1 …</em></strong></p><blockquote>Go!!!</blockquote><p>Well, thank you for reading, I hope you enjoyed it. If you have some advice, positive or negative, please do comment. Don’t be cheap with 👏 👏 👏 if you they deserved😉. And find me on <a href="https://twitter.com/dido_aint">twitter</a> if you need me. Till next time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d77964b1a05" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to record your screen interaction with iOS 11?]]></title>
            <link>https://medium.com/series/how-to-record-your-screen-interaction-with-ios-11-c73bab1ea2de?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/c73bab1ea2de</guid>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Mon, 02 Oct 2017 13:21:23 GMT</pubDate>
            <atom:updated>2017-10-02T13:21:23.348Z</atom:updated>
            <content:encoded><![CDATA[<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c73bab1ea2de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating the tedious parts of your life as an iOS developer by mixing GitLab CI and fastlane like…]]></title>
            <link>https://medium.com/@didoaint/automating-the-tedious-parts-of-your-life-as-an-ios-developer-by-mixing-gitlab-ci-and-fastlane-4ab1f70ed6ed?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ab1f70ed6ed</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[testflight]]></category>
            <category><![CDATA[fastlane]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Thu, 28 Sep 2017 14:46:24 GMT</pubDate>
            <atom:updated>2017-10-04T18:25:35.078Z</atom:updated>
            <content:encoded><![CDATA[<h3>Automating the tedious parts of your life as an iOS developer by mixing GitLab CI and fastlane like a boss</h3><h4>That may lead to the increase of one of the following: productivity, caffeine, free time, friends at work.</h4><blockquote>This post serves as a continuation of <a href="https://medium.com/@didoaint/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272">How to set up GitLab CI for iOS in three relatively simple steps</a> and assumes that you have GitLab CI already running for a a project of your choosing.</blockquote><h4>Introduction</h4><p>In my <a href="https://medium.com/@didoaint/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272">previous post</a>, I showed how some people use GitLab CI for iOS and I showed how I implemented it myself. But guess what? You can take things a bit further and improve your nice set-up with the goal of automating all the tedious tasks connected with building and releasing your app. That is right, it is <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a><strong> </strong>that I have in mind(<em>you should know that if you read the title </em>😃). So, keep reading till the end and I promise that running unit tests and uploading a new version to <strong>TestFlight</strong> for your project will feel like a breeze 🌬.</p><h4>How did we start using <a href="https://github.com/fastlane/fastlane">fastlane</a> at work?</h4><p>Ok, look, I work at a small start-up company with a workforce of a bit over 10 people and I am part of the iOS team. I will not go into details of how we organize the workflow and etc., I will just say that we are in charge of all of it. So, yeah, when we start out building a new app, we do it all — planning, development, betas, production versions, releasing, all the buzzwords you can think of 🙏. Do not understand me wrong — I like things this way, it keeps my developer’s live way more interesting.</p><p>But what is it that is not so interesting about my way more interesting developer’s life? 🐼🔫 There might be other things that come to mind, buuuut I am talking about deploying an app to the appstore— dealing with provisioning profiles(<em>sometimes on different machines</em>), uploading different versions(<em>forgetting to increment the build number</em>), receiving random weird errors. Is any of this actual programming? Doubt it. And, hey, we are not even considering the time wasted(<em>time is money they say 💸</em>).</p><p>And voilà 🏄, what a satisfying feeling when <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> is all set and working:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*4mFV6S2LU2mYqdYNUigdIQ.png" /></figure><h4>So, how to set up <a href="https://github.com/fastlane/fastlane">fastlane</a> to work with GitLab CI for iOS deployment and feel that satisfying feeling?</h4><p>First of all, you need to install the required tools for using fastlane — Xcode command line tools and <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> itself obviously. You can do that following these <a href="https://docs.fastlane.tools/getting-started/ios/setup/#getting-started-with-fastlane-for-ios"><strong>instructions</strong></a><strong> </strong>where<strong> </strong>providing your <strong>Apple ID</strong> will be the most important thing to start with, I am sure you know that one 😃. <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> then automatically does its magic and in your <strong>project’s directory</strong> you should see a <strong>fastlane</strong> <strong>folder</strong> containing all your metadata from <strong>iTunes Connect</strong>. I recommend starting with paying special attention to:</p><ul><li>the<strong> Appfile</strong>(your<em> app and your account info is here</em>).</li><li>the<strong> Fastfile</strong>(<em>your instructive lanes are here, a.k.a. the key to lazy productivity</em>).</li><li>the rest of the metadata varies depending on whether you had your app on <strong>iTunes Connect</strong> before or after you started using <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a>.</li></ul><blockquote>If you are now wondering what exactly a <strong>Fastfile</strong> consists of? Plainly said, it is Ruby code. But if you are the more curious, <a href="https://stackoverflow.com/questions/41939283/what-exactly-is-the-code-in-a-fastfile">this</a> and <a href="https://www.martinfowler.com/articles/rake.html">this</a> should clarify things further.</blockquote><p>And that is it, <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> is ready to be used 🎊. Only locally though<strong>, </strong>meaning the command line 😢. That may be enough if you are a freelancer and you work on your own, or you are the one-person iOS team in your company. But most of the time, that is not the case. You want to have things ready once and you want the configuration to be used by everyone in your iOS team. Luckily, you read my previous <a href="https://medium.com/@didoaint/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272">post</a> and you have <strong>GitLab CI </strong>waiting to be mixed with <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a><strong> </strong>and thus creating a beautiful cocktail 🍹.</p><blockquote>Ideally, you would want your CI set-up to run on a separate server that is available 24/7.</blockquote><p>If you read the <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> installation instructions closely, at the <a href="https://docs.fastlane.tools/getting-started/ios/setup/#use-a-gemfile"><strong>bottom</strong></a> it is mentioned that you should use a <strong>Gemfile </strong>to easily define your dependency on the latest stable version of<strong> </strong><a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a>. So, yeah, keep reading and make sure you have <strong>bundler</strong> installed, and that pretty <strong>Gemfile </strong>positioned<strong> </strong>in the root directory of your project containing this:</p><pre>source &quot;https://rubygems.org&quot;</pre><pre>gem &quot;fastlane&quot;</pre><p>If you use Cocoapods in your project, well, add a line for them to the file too(<a href="https://medium.com/@didoaint/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272"><em>last time</em></a><em> we put the Cocoapods installation instructions in the </em><strong><em>GitLab YAML file</em></strong><em>, now we put them in the </em><strong><em>Gemfile</em></strong>):</p><pre>gem &quot;cocoapods&quot;</pre><p>This should be enough of configuration for your <strong>Gemfile</strong> at this point.</p><p>Next comes the actual setting up of the collaboration between <strong>GitLab CI</strong>(<strong><em>the .gitlab-ci.yml file</em></strong>) to work with <strong>bundler</strong>(<strong><em>the Gemfile</em></strong>) and <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> and this is the result we are looking for:</p><ol><li><strong>GitLab CI</strong> starts out by first calling <strong>bundler</strong> which installs <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> and the <strong>needed Cocoapods</strong>.</li><li><strong>GitLab CI </strong>then<strong> </strong>starts executing its pre-set stages as usual. This time however, these stages contain calls to the respectively configured lanes in the <strong>Fastfile</strong>. In other words, <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> will be the tool to direct the CI execution.</li><li><a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> does its thing according to the instructions provided — it is the same as using <a href="https://github.com/fastlane/fastlane"><strong>fastlane</strong></a> through the command line but automated with the help of <strong>GitLab CI</strong>.</li></ol><p>Alright then, we have the <strong>Gemfile</strong> ready, we need the other two. Let me show you what I have for a <strong>YAML</strong> file:</p><pre>stages:<br>  - test<br>  - deploy<br><br>before_script:<br>  - gem install bundler<br>  - bundle install<br><br>unit_tests:<br>  stage: test<br>  script:<br>    - fastlane test<br>  tags:<br>    - ios<br><br>deploy_beta:<br>  stage: deploy<br>  script:<br>    - fastlane beta<br>  tags:<br>    - ios<br>  only:<br>     - beta</pre><p>Starting with <em>stages</em>, there are obviously two that I have in mind — one for testing and one for deploying<em>(a new version)</em>. Before the actual script runs, I call the installation of <strong>bundler</strong> itself with <strong><em>gem install bundler </em></strong>and with<strong><em> bundle install</em></strong> I call the instructions in<strong><em> </em></strong>the<strong> Gemfile</strong>.<strong><em> </em>GitLab CI</strong> should now be ready to run the <strong><em>unit_tests</em></strong> job for <strong>every branch</strong> in the project<em>(we would generally want to run the unit tests with every important commit, right?)</em> and the <strong><em>deploy_beta</em></strong> job for the <strong>beta branch</strong> only<em>(we merge with beta branch every time we want a new beta version to be uploaded to </em><strong><em>TestFlight</em></strong><em>;</em><strong><em> </em></strong><em>so yeah, it is assumed you have a </em>beta branch<em> too, and if you don&#39;t, make one </em>😃<em>)</em>.</p><p>Lets go back to the <strong>Fastfile</strong> and set up the <strong><em>test</em></strong> and <strong><em>beta</em></strong> lanes. The <strong><em>test</em></strong> lane is quite straightforward:</p><pre>lane :test do<br>    scan(scheme: &quot;YourAppSchemeName&quot;)<br>  end</pre><p>The <strong><em>beta</em></strong> lane is a bit more sophisticated but nothing too crazy:</p><pre>lane :beta do <br>    increment_build_number ({ <br>    build_number: latest_testflight_build_number + 1<br>    })</pre><pre>    match(app_identifier: &quot;YourAppIdentifier&quot;,<br>    type: &quot;appstore&quot;,<br>    force: true<br>    )</pre><pre>    gym(scheme: &quot;YourAppSchemeName&quot;,<br>    silent: true,<br>    clean: true)   <br> <br>    pilot<br>  end</pre><p>So, one by one:</p><ul><li><strong><em>increment_build_number</em></strong> and the corresponding in-bracket calculation always make sure that you properly implement the build number of the project that you upload to <strong>TestFlight</strong>.</li><li><strong><em>match </em></strong>is one of my favorites cause it makes sure that you always have all required certificates and provisioning profiles shared in a git repo for all team members to use. However, it needs special preparation so you need to read a bit about it <a href="https://github.com/fastlane/fastlane/tree/master/match#usage">here</a>. If you are still wondering about the configuration I have — <strong><em>type</em></strong> is for type of codesigning identity you are using and <strong><em>force: true</em></strong><em> </em>makes sure that your app’s provisioning profile is always up-to-date.</li><li><strong><em>gym</em></strong> makes sure that we get a nice, <strong><em>clean</em></strong>(<em>fresh installation</em>)<strong><em> </em></strong>and<strong><em> silent</em></strong>(<em>only readable info is showed to us on the command line</em>)<strong><em> </em></strong>project build before we try uploading a new version.</li><li><strong><em>pilot</em> </strong>is for uploading to <strong>TestFlight</strong>.</li></ul><p>And that should do it provided that you followed all the instructions closely. Go ahead, make a commit to <strong>any branch</strong> to invoke some unit testing and when you are ready, merge or commit to the <strong>beta branch</strong> to start an upload of a new beta to <strong>TestFlight</strong>.</p><p>Well, thank you for reading, I hope you enjoyed it. If you have some advice, positive or negative, please do comment. And some 👏 👏 👏 would be nice if you feel like it 😉. Till next time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ab1f70ed6ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to set up GitLab CI for iOS in three relatively simple steps]]></title>
            <link>https://medium.com/static-object/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272?source=rss-f1ce655c1974------2</link>
            <guid isPermaLink="false">https://medium.com/p/56a0d88d0272</guid>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[xcode]]></category>
            <category><![CDATA[gitlab-runner]]></category>
            <category><![CDATA[gitlab]]></category>
            <dc:creator><![CDATA[Deyan Aleksandrov]]></dc:creator>
            <pubDate>Tue, 29 Aug 2017 12:44:15 GMT</pubDate>
            <atom:updated>2017-10-12T17:38:12.139Z</atom:updated>
            <content:encoded><![CDATA[<h4>Hint: It is not hard at all.</h4><blockquote>My own GitLab set-up for work as well as this post came to life thanks to <a href="https://about.gitlab.com/2016/03/10/setting-up-gitlab-ci-for-ios-projects/">Angelo Stavrow’s post from 2016</a>. Make it all spicier adding fastlane to the jam, find the link for my next article at the end of this post.</blockquote><h4><strong>Introduction</strong></h4><p>As developers, young or old, junior or senior, or whatever the title, we all hear about CI/CD and the tools available — there are a lot of paid ones while others are free if your project is open source for example. Cool, I know. But about work that is not open source? You are in luck if you are using GitLab because it <a href="https://about.gitlab.com/features/gitlab-ci-cd/">comes with CI built-in</a> for free, no matter the project. That sounds like… a goood plan :-).</p><p>I will not go into explaining what CI/CD is, you can easily google it. But I need to note that the greater advantage, for myself at least, of having CI is that it will make you write those damn tests you have been procrastinating. So, lets do this.</p><h4><strong>What set-up is used for this post?</strong></h4><ul><li>A <strong>Mac mini</strong> running <strong>macOS Sierra 10.12.6</strong></li><li><strong>Xcode 8.3.3</strong> with the <strong>iOS 10.3 SDK</strong></li></ul><h4><strong>First step — setting up your Xcode project</strong></h4><ul><li>Start of by creating your project including Unit and/or UI tests and linking it with a corresponding GitLab repository.</li><li>Really, really make sure that you <strong>share your project’s scheme</strong> because otherwise GitLab CI cannot locate the context it needs to build and test your project. To do that, you need to open your project in Xcode and choose <strong>Product</strong> &gt; <strong>Scheme</strong> &gt; <strong>Manage Schemes </strong>from the tab menu<strong>.</strong></li><li>When the menu window shows up, tick the <em>Shared box </em>corresponding to your project’s scheme and then click the <em>Close</em> button</li></ul><blockquote><em>There is no need to share any dependency schemes.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pbWLV_ntmKgBXWJH4yNWUg.png" /></figure><ul><li>When done with the above steps, you can commit and push.</li></ul><blockquote>A good idea is to <a href="https://github.com/supermarin/xcpretty"><strong><em>get xcpretty</em></strong></a><strong><em>. </em></strong>It<strong><em> </em></strong>transforms the output of your build into something way more readable.</blockquote><h4><strong>Second step — installing and registering a GitLab Runner</strong></h4><p>To really get a good sense of what Runners are, you can check out <a href="https://docs.gitlab.com/ee/ci/runners/README.html">GitLab’s documentation about them</a>. Explained in short — it is a service on your computer (<em>it could be a remote server somewhere but it will be on your Mac since you are an iOS developer which makes you special :-)</em>) that runs a certain build and its corresponding test process which you get to set up in a special configuration file.</p><p>The actual installation of a GitLab runner on your Mac is quite straightforward so I do recommend following the <a href="https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/blob/master/docs/install/osx.md#install-on-macos">instructions provided by our GitLab friends specifically for macOS</a>.</p><p>It is the registration of your GitLab Runner that can be confusing at certain steps. There are indeed <a href="https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/blob/master/docs/register/index.md#macos">instructions</a> on how to do that too(<em>so please follow them</em>) but I do need to point out a few particularities:</p><ul><li>When performing the <strong>registration process</strong>, make sure it is done in <strong>user-mode</strong>, meaning — there is no need for using <strong><em>sudo </em></strong>in front of every command. Actually, make sure you do not use <strong><em>sudo</em></strong> here because the registration will not work. Believe me, I tried it.</li><li><strong>In step 2 </strong>in the instructions, you are asked to <em>enter your GitLab instance URL</em>. What worked for me was entering <strong><em>https://gitlab.com/ci</em></strong></li><li><strong>In step 8 </strong>in the instructions, you are asked to enter the Runner executor. Enter <strong><em>shell</em></strong>.</li><li>Your runner should be up and running. You can see that from the command line using the command <strong><em>gitlab-runner verify</em></strong> or when you go to your project’s page in GitLab’s web site, choose <strong>Settings &gt; CI/CD</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*As3N8zgquttT1vxZ0TsWbw.png" /></figure><ul><li>There are two things to note in the above screenshot — <strong>the first one</strong> is that I have set up two <strong>Specific Runners</strong> for my project and I am using just one of them, and <strong>the second one</strong> is that <strong>I have disabled the Shared Runners </strong>which is how I<strong> </strong>make certain that a <strong>Specific Runner</strong> I have chosen runs my project. The <strong>Shared Runners </strong>will not work for an iOS project.</li></ul><h4><strong>Third step — configuring the build and test settings using a YAML file</strong></h4><p>For those of you who have experience with other CI tools may have seen or configured a YAML file before. Well, with GitLab CI, the configuration is pretty similar — it is just that the YAML file needs to named .gitlab-ci.yml.</p><p>For the others that have no experience with such configurations, <a href="https://docs.gitlab.com/ce/ci/quick_start/README.html#creating-a-gitlab-ci-yml-file">please check out the instructions on creating a </a><a href="https://docs.gitlab.com/ce/ci/quick_start/README.html#creating-a-gitlab-ci-yml-file">.gitlab-ci.yml file</a> and you will see how easy it is. Just make sure that the file is saved in the proper place in your Xcode project folder.</p><p>I will provide you with two examples of a .gitlab-ci.yml file created for iOS projects:</p><ul><li>The first one is <a href="https://about.gitlab.com/2016/03/10/setting-up-gitlab-ci-for-ios-projects/">Angelo Stavrow’s</a>. Scroll down to <strong>Installing and registering the GitLab Runner</strong>. A bit bellow it you will see a configuration with respective explanation for a Xcode project with no dependencies(<a href="https://cocoapods.org/"><em>Cocoapods</em></a><em> for example</em>). The configuration looks like this<strong>:</strong></li></ul><pre>stages:<br>  - build<br><br>build_project:<br>  stage: build<br>  script:<br>    - xcodebuild clean -project ProjectName.xcodeproj -scheme SchemeName | xcpretty<br>    - xcodebuild test -project ProjectName.xcodeproj -scheme SchemeName -destination &#39;platform=iOS Simulator,name=iPhone 6s,OS=9.2&#39; | xcpretty -s<br>  tags:<br>    - ios_9-2<br>    - xcode_7-2<br>    - osx_10-11</pre><ul><li>The second one is a set-up of mine for a project with <em>Cocoapods</em>. I only have one stage but I am building for two different environments, and I have no tags because my runner is set up to work without them. Please do notice the difference in the naming after the <strong><em>xcodebuild script</em></strong> <strong><em>command</em></strong>. I am clean building and testing a <strong><em>workspace</em></strong> instead of a <strong><em>project </em></strong>for just one branch named<strong><em> addingTestsToProject</em></strong>:</li></ul><pre>stages:<br>  - build<br>  <br>build_project_1:<br>  stage: build<br>  script:<br>    - xcodebuild clean -workspace WorkSpaceName.xcworkspace -scheme SchemeName | xcpretty<br>    - xcodebuild test -workspace WorkSpaceName.xcworkspace -scheme SchemeName -destination &#39;platform=iOS Simulator,name=iPhone SE,OS=10.3.1&#39; | xcpretty -s<br>  only:<br>    - addingTestsToProject<br>    <br>build_project_2:<br>  stage: build<br>  script:<br>    - xcodebuild clean -workspace WorkSpaceName.xcworkspace -scheme SchemeName | xcpretty<br>    - xcodebuild test -workspace WorkSpaceName.xcworkspace -scheme SchemeName -destination &#39;platform=iOS Simulator,name=iPhone 6,OS=10.3.1&#39; | xcpretty -s<br>  only:<br>    - addingTestsToProject</pre><h4>Conclusion</h4><p>This is how it is done! Well, most of it at least because, believe me, a YAML file can be really <a href="https://docs.gitlab.com/ee/ci/yaml/#gitlab-ci-yml">sophisticated</a>. What I provided you with is quite simple and I hope it will be a good start for some and refreshment for others.</p><p>In my next post, I will share how I got to set up GitLab CI and <a href="https://fastlane.tools/">fastlane</a> to work together to save me time and effort in developer activities. Read about that <a href="https://medium.com/@didoaint/automating-the-tedious-parts-of-your-life-as-an-ios-developer-by-mixing-gitlab-ci-and-fastlane-4ab1f70ed6ed?source=linkShare-f1ce655c1974-1506972643">here</a>.</p><p>Until then, please do ask a question if you find something unclear and do share advice on what I could do better.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56a0d88d0272" width="1" height="1" alt=""><hr><p><a href="https://medium.com/static-object/how-to-set-up-gitlab-ci-for-ios-in-a-few-relatively-simple-steps-56a0d88d0272">How to set up GitLab CI for iOS in three relatively simple steps</a> was originally published in <a href="https://medium.com/static-object">GitClear</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>