<?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 Mark Finkle on Medium]]></title>
        <description><![CDATA[Stories by Mark Finkle on Medium]]></description>
        <link>https://medium.com/@mfinkle?source=rss-82c69a028ff------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*mADyKeyXETyUjytv.jpg</url>
            <title>Stories by Mark Finkle on Medium</title>
            <link>https://medium.com/@mfinkle?source=rss-82c69a028ff------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:44:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mfinkle/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[Exploring LLMs and Agents]]></title>
            <link>https://medium.com/@mfinkle/exploring-llms-and-agents-82f5f0c2ac8a?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/82f5f0c2ac8a</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Wed, 02 Jul 2025 02:51:25 GMT</pubDate>
            <atom:updated>2025-07-02T02:51:25.163Z</atom:updated>
            <content:encoded><![CDATA[<p>I ended up writing a series of blog posts detailing my exploration into LLMs and building Agents. I start from a very basic, minimalist code base and build up from there.</p><p>Take a look at the <a href="https://github.com/mfinkle/llm-agents">repository</a> to see the code.</p><ul><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-a-minimalist-approach/">Minimalist Approach</a>: I kicked off my exploration by making two agents using the bare-minimum dependencies. I wanted to learn the concepts, before using a do-it-all framework.</li><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-taking-action/">Taking Action</a>: I decided to focus on the tool_agent and add some read/write tools for the agent to use. I also discovered the need to send clear and consistent context in prompts.</li><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-planning-via-prompting/">Planning via Prompting</a>: I looked at ways to improve the agent outcomes by using better approaches to planning. I settled on using ReAct, with some Few-Shot prompts, and had the LLM do some Chain of Thought (CoT) output.</li><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-tools-benchmarking/">Tools &amp; Benchmarking</a>: I refactored the ToolAgent code into a reusable base class, added some additional mock tools, and even some basic benchmarking.</li><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-webagent-gets-a-refactor/">WebAgent Gets a Refactor</a>: After refactoring ToolAgent, I decided to see if I could build WebAgent on top of ToolAgent. I think it turned out pretty nicely. Again, Copilot helped too.</li><li><a href="https://starkravingfinkle.org/blog/2025/03/exploring-llms-as-agents-model-context-protocol/">Model Context Protocol (MCP)</a>: This post is about MCP-enabling the ToolProvider and ToolAgent framework I created! That’s right, I’m exposing ToolProviders as MCP Servers and ToolAgent as an MCP Client — and I’m doing it with <strong>zero dependencies</strong> on any MCP framework.</li><li><a href="https://starkravingfinkle.org/blog/2025/04/exploring-llms-as-agents-local-models/">Local Models</a>: I finally got around to exploring local models, which is surprisingly simple to set up. I wanted to see how well a local model would perform in ToolAgent compared to the remote models (mostly Gemini) I have been using.</li></ul><p>I learned a lot during this series, not only about LLMs &amp; Agents, but also using code-assistants to help with the coding too. I had a lot of fun.</p><p>More to come.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82f5f0c2ac8a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Digest: 2019]]></title>
            <link>https://medium.com/@mfinkle/digest-2019-231ee1f1d4af?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/231ee1f1d4af</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[organizational-culture]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Thu, 16 Jan 2020 06:20:39 GMT</pubDate>
            <atom:updated>2020-01-16T06:20:39.727Z</atom:updated>
            <content:encoded><![CDATA[<p>I haven’t been publishing directly to Medium much lately, but I thought I’d at least create a digest post with things I’ve been writing on my <a href="https://starkravingfinkle.org/blog">blog</a>.</p><h3>Thoughts on Dependency Injection</h3><p><em>march 24, 2019</em></p><p>I hear some strong opinions on <a href="https://en.wikipedia.org/wiki/Dependency_injection">dependency injection</a> (DI). I’ve never really thought too much about DI specifically, but it is part of an <a href="https://en.wikipedia.org/wiki/Inversion_of_control">Inversion of Control</a> strategy, which I think about a lot.</p><p><a href="https://starkravingfinkle.org/blog/2019/03/thoughts-on-dependency-injection/"><em>continue reading</em></a></p><h3>Thoughts on Organizational Culture</h3><p><em>july 20, 2019</em></p><p>I’ve been thinking a lot about why it seems so hard to effect change in organizations. The change I’m referring to could be related to product strategy, processes, or improving engineering / operational excellence.</p><p>I’ve come to realize that in many situations our efforts and plans don’t always align with the organization’s culture. When that happens, change is difficult.</p><p><a href="https://starkravingfinkle.org/blog/2019/07/thoughts-on-organizational-culture/"><em>continue reading</em></a></p><h3>Shipping Faster: The Hackday Mentality</h3><p><em>august 31, 2019</em></p><p>We recently held our Summer Hackday at Tumblr and the results were impressive. I started to think about the mentality of a Hackday and how it differs from a more traditional product feature workflow.</p><p>It’s amazing what can be accomplished in a day.</p><p><a href="https://starkravingfinkle.org/blog/2019/08/shipping-faster-the-hackday-mentality/"><em>continue reading</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=231ee1f1d4af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web ADB: Simple Web-based Access to Devices]]></title>
            <link>https://medium.com/@mfinkle/web-adb-simple-web-based-access-to-devices-aa60e8a2a20b?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa60e8a2a20b</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[web]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Sun, 25 Nov 2018 02:09:09 GMT</pubDate>
            <atom:updated>2018-11-26T16:59:26.459Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p>I’ve had a number of occasions where I needed direct access to an Android device that wasn’t connected to the computer in front of me. I can usually SSH into the remote host machine and use ADB to try to debug the situation. If the simple stuff doesn’t work, I eventually start using <a href="https://developer.android.com/studio/command-line/adb#screencap">ADB screencap</a> to get a look at what’s on the device. If I’m lucky, I can remote desktop to the host. If not, I end up copying the images back to my machine to view them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*DkgovnX5Qv9MnHenqfcGJg.png" /><figcaption>Connecting to a remote host with some Android devices attached to it</figcaption></figure><p>Surely there is must be an easier way.</p><p>There is! I found the <a href="https://openstf.io/">OpenSTF</a> project which basically allows you to get web-based control of the Android and iOS devices. Just install the system on the host machine and install an agent on the Android devices. It looks pretty cool, but always seemed like overkill when I was in a remote debug situation.</p><p>So I decided I’d start hacking together a really simple system in Python. I started with the simplest Python API server I could find. Then I added a fairly basic webapp front-end. The result is <a href="https://github.com/mfinkle/web-adb">Web ADB</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9V8lfJUQzBVodvzD.png" /></figure><p>It’s a very minimal Python API server, which also serves up a basic single-page webapp. The approach is pretty simple: run ADB commands via Python, parse the output, send the results back through the API response.</p><p>The API supports getting attached devices, getting a screenshot of a device, sending key presses and screen taps, and even rebooting a device. The webapp just uses the API to make something useful. Maybe the only cool feature is clicking on a screenshot will send a tap to the device, then update the screenshot. I have some ideas for other features, as time permits.</p><p><em>Originally published at </em><a href="http://starkravingfinkle.org/blog/2018/11/web-adb-simple-web-based-access-to-devices/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa60e8a2a20b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stability: Monitoring Application Crashes]]></title>
            <link>https://medium.com/@mfinkle/stability-monitoring-application-crashes-d29c3c540463?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/d29c3c540463</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[monitoring]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Sat, 29 Sep 2018 21:22:26 GMT</pubDate>
            <atom:updated>2020-09-28T16:52:24.310Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lwcUf1GhyXmiJ-0o.png" /></figure><p>Crashes are inevitable. For an application with many people actively using it, the amount of crashes is probably higher than you’d imagine. Thankfully, there are many in-house and third-party systems that allow you to track crashes with detailed meta data and crash stacks.</p><p>It takes some practice and diligence, but you can get very good at managing and fixing the most relevant crashes in your application.</p><p>When I started working at Tumblr, I noticed they were using an additional approach to tracking crashes: <strong>a real-time, low-cardinality, crash event</strong></p><p>Hooked up to the time-series collection system used for other monitoring, you get a very up-to-date measure of the crash rate. It was the first time I’d seen crash rate measured this way. Plenty of crash tracking systems allow you to look at crash rate, but usually at the hourly level. Ingestion can take non-trivial amounts of time when dealing with parsing, symbolicating, and deobfuscation.</p><p>The real-time crash monitoring is perfect for alerting too. The time-series system already had support for notifying developers or paging on-call people.</p><p><a href="https://martinfowler.com/articles/feature-toggles.html">Feature flags</a> are an awesome way to ramp new functionality in a controlled manner. I’ve seen real-time crash monitoring catch issues moments after a problematic ramp. If you’re using feature flags, you should be using real-time crash reporting as well. It’s enormously beneficial and relatively simple to implement.</p><p><em>Originally published at </em><a href="https://starkravingfinkle.org/blog/2018/09/stability-monitoring-application-crashes/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d29c3c540463" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Decisions, Decisions, Decisions]]></title>
            <link>https://medium.com/@mfinkle/decisions-decisions-decisions-32dac9db6dff?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/32dac9db6dff</guid>
            <category><![CDATA[decision-making]]></category>
            <category><![CDATA[management]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Sun, 19 Aug 2018 03:46:36 GMT</pubDate>
            <atom:updated>2020-09-28T17:05:02.719Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p>A big part of leading people and teams is making decisions. You can’t move forward without making decisions. As the lead, or manager, it’s part of your job. Don’t pass it down to someone on your team. They’re looking to you.</p><ul><li><strong>Get the facts:</strong> Try to be well informed about the situation, the inputs effecting the decision, and the outcomes from the decision. If you’re not well informed, start asking people who are. They might have the information, or parts of it, but aren’t in the position to make the decision.</li><li><strong>Trust your gut:</strong> It’s unlikely you’ll ever have 100% of the information you need. That’s fine, the <a href="https://digitalkickstart.com/the-4070-rule-and-how-it-applies-to-you/">40/70 rule</a> says waiting for 100% is waiting too long.</li><li><strong>Know the risks:</strong> Not all decisions will be the right decision. Mistakes happen, but the trick is trying to minimize the cost of a potential mistake by knowing and lowering the risk. People point to the <a href="https://www.businessinsider.com/i-tried-the-101010-method-inspired-by-warren-buffett-and-ray-dalio-2017-10">10/10/10 approach</a> as a way to do this.</li><li><strong>Be consistent:</strong> Try to have a process or convention or guideline or philosophy to fall back on to help shape your decision. Exceptions can happen, but decisions are easier to make if you have a well know starting place to build from.</li><li><strong>Don’t delay:</strong> The longer it takes to make a decision, the more problematic a situation can become. In the long run, every decision is short term. Delays keep the team from moving forward. Brian Valentine, lead developer on Windows 2000, had a <a href="https://news.microsoft.com/2000/02/16/the-motivator-behind-the-windows-2000-development-team/">famous quote</a>: “Decisions in 10 minutes or less, or the next one is free.”</li></ul><p>These guidelines can be useful when you’re in a period of heavy decision making. <a href="https://en.wikipedia.org/wiki/Decision_fatigue">Decision fatigue</a> is a real condition. It can lead to a reduced ability to make trade-offs, understand risk, or even just flat out avoid making the decision altogether. If you’re not prepared, your decisions will suffer and so will your team.</p><p><em>Originally published at </em><a href="https://starkravingfinkle.org/blog/2018/08/decisions-decisions-decisions/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32dac9db6dff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Random Thoughts on Team Structure]]></title>
            <link>https://medium.com/@mfinkle/random-thoughts-on-team-structure-5d8774b1aca?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d8774b1aca</guid>
            <category><![CDATA[team-building]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Mon, 07 Aug 2017 15:53:38 GMT</pubDate>
            <atom:updated>2020-09-28T17:11:50.672Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*303CAqFwGV7psd51.jpg" /></figure><p>I’ve written <a href="http://starkravingfinkle.org/blog/2013/07/patterns-of-effective-teams/">previously</a> about my thoughts on team structure. I’m a fan of product-centric teams — multidisciplinary teams that embed members from functional groups on the same team, all working together to create and ship a software product.</p><p><strong>Team Evolution</strong></p><p>At some point, a team might grow large enough that you want to split into smaller groups, each with a primary focus. You’re still building a single product, but now you have a collection of product-centric teams working on specific features. How did you get here?</p><ul><li>Teams get harder to manage and coordinate as they grow in size.</li><li>Product-drivers feel like it’s a struggle to get development focus on their features.</li></ul><p>I’ve been able to work in both situations: single product-centric team, and multiple feature-based teams. My preference is still the single product-based team. The downsides of feature-based teams outweigh the advantages.</p><ul><li>Teams become silos and stop focusing on the product as a whole.</li><li>Issues without a clear owner become <em>someone else’s problem</em>.</li><li>Cross-team communication becomes more difficult as more groups are created.</li><li>Individual team ambitions inadvertently dilute the primary focus of the product.</li></ul><p><a href="https://www.thoughtworks.com/insights/blog/demystifying-conways-law">Conway’s Law</a> tells us that organizations tend to build products based on the organization’s structure. Using several small teams, with a focus on specific features, will have an effect on the final product. It might not be a desired effect.</p><p><strong>Mindful Divisions</strong></p><p>I’m not suggesting teams grow beyond 7 to 10 people. There is plenty of literature, and experience, that tells us that would be bad, and even <a href="https://hbr.org/2012/08/why-less-is-more-in-teams">less efficient</a>. But how you divide teams is important. Some divisions are more natural than others:</p><ul><li><strong>By platform</strong> (Desktop, Android, iOS, Web): Make sure there is some product consistency across platforms.</li><li><strong>By front-end / back-end</strong>: Make sure both sides are part of defining the interaction APIs.</li><li><strong>By application / UI widgets</strong>: Make sure both sides are part of defining the component APIs.</li></ul><p>These separations are clean and easier to identify.</p><p><strong>Feature Survival</strong></p><p>Single product-centric teams bring us back to the issue of product-drivers fighting for development focus. I think this is a good thing.</p><p>When features are implemented through a single team, you need to be good at prioritizing. It shouldn’t be easy to add every little feature to the product. By making all features compete for priority, you make sure the best features get the attention.</p><p>I believe this makes the product stronger.</p><p><em>Originally published at </em><a href="https://starkravingfinkle.org/blog/2017/08/random-thoughts-on-team-structure/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d8774b1aca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Performance: Design & Expectations]]></title>
            <link>https://medium.com/@mfinkle/performance-design-expectations-b36822068a1c?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/b36822068a1c</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Sun, 09 Jul 2017 15:04:26 GMT</pubDate>
            <atom:updated>2020-09-28T17:13:43.484Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WbaB3jmsThkDeWyN.jpg" /></figure><p>Providing a great user experience under a variety of performance situations means designing for a variety of expectations. Defining a great user experience should include <a href="https://timkadlec.com/2013/01/setting-a-performance-budget/">performance budgets</a> for the various pieces of the experience. Some basic examples include: Application startup, Image loading, and UI responsiveness.</p><p><strong>Application Startup</strong></p><p>First impressions are important, and startup time (page-load for web apps) is that first impression. There is a lot of information floating around that should convince you of the importance of a fast launch time. Still, we seem to cram more and more cruft into that part of the application. We initialize analytic libraries, load saved preferences, try to re-send failed or queued events and data, and maybe even send crash reports from previous sessions.</p><p>Create a startup time performance budget. How long should a person wait before being able to view and interact with real content? Once you set that limit, start moving less critical work out of the critical path. Queued events and data can remain queued a little while longer. Buffer new events before initializing heavy analytics libraries. Consider showing cached content, while downloading new content in the background.</p><p><strong>Image Loading</strong></p><p>Images are a big part of many applications. Avatars, photos and GIFs are everywhere. We want to display the images as fast as possible. Usually development happens in ideal situations: Best devices and best network speeds — the fast-path. If you’re measuring the real world performance characteristics of your application, you probably know that most of the people using the application don’t have the best devices or fast network speeds — the slow path.</p><p>Sometimes we fail to design for the slow-path. We assume it’s infrequent, or worse, we believe the fast-path behavior is correct for the product in any situation. People can just deal with the crummy experience. Remember your performance budget: how long should someone wait for an image to load?</p><p>Some common approaches to handling the slow-path:</p><ul><li>Use server-side caching. This one is pretty obvious, but I have to mention it. Using a Content Delivery Network (CDN) means it takes less time to deliver images to the application because the images are “closer” to the application.</li><li>Use a more efficient file format. GIF is not known for being a lightweight format. Look into <a href="http://cloudinary.com/blog/quick_guide_using_webp_on_your_website_or_native_apps">WebP</a> and <a href="https://rigor.com/blog/2015/12/optimizing-animated-gifs-with-html5-video">MP4</a> as low-bandwidth animated image alternatives that provide great quality.</li><li>Get better at picking JPEG quality levels. Etsy has a nice <a href="https://codeascraft.com/2017/05/30/reducing-image-file-size-at-etsy/">write-up</a> on using SSIM (human vision estimation) to pick the lowest level without hurting perceived quality. Google has something called <a href="https://github.com/google/butteraugli">Butteraugli</a> that does something similar.</li><li>Dynamically size images to fit the target rendering size. Don’t download large images only to reduce the size on the client. For less than excellent networking speeds, request images that are smaller than the target size and upscale them. You can save a lot of bandwidth and render the image quickly, keeping the application usable.</li><li>Aggressively cache images on the device. Never download the same image more than once. Cached images load quickly and reduce bandwidth usage. Yes, this might mean using 1GB or more for a cache, but if the space is available, it’s always worth it. Modern OSes will try to clear storage-based caches when running low on free space.</li><li>Consider <em>Tap-to-Play</em> interfaces to delay downloading large animated images until requested. Use a much smaller static image as a placeholder.</li></ul><p>Some of these slow-path ideas might be so effective at saving bandwidth or improving image loading speed, that you make them options for the fast-path as well.</p><p><strong>UI Responsiveness</strong></p><p>Touch-based devices make unresponsive UIs very noticeable. Applications should maintain a responsive UI no matter what other activity is taking place. Use background threads to do the heavy lifting. Keep the UI thread free of any file I/O, networking and any other work that can be pushed to the background.</p><p>Remember to design for the slow-path when creating UI actions associated with network APIs. Don’t wait for the network response before changing the state of the UI. If the action fails, you can always say so and flip the state back. Delaying the state change makes the UI appear broken.</p><p>Smooth scrolling is another part of a responsive UI. iOS, Android and Web all have best practices for keeping high frame-rates while scrolling. There are also tools for profiling your rendering code.</p><p>Watch for situations where a design requirement (animation, layout, whatever) is causing the UI to become unresponsive. Find a way to fast-path/slow-path the requirement. If that’s not possible, get the requirement changed.</p><p><strong>Design for Everyone</strong></p><p>Never fall into the mindset of designing for only the latest hardware and fastest network speeds. You really need to factor the slow-path into your designs too. Yes, it’s more work and it’s probably not your ideal experience, but it’s far better than trying to force a fast-path design down a slow-path situation. That experience is usually horrible. You can do better!</p><p><em>Originally published at </em><a href="https://starkravingfinkle.org/blog/2017/07/performance-design-expectations/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b36822068a1c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Performance: The Merits of Measuring]]></title>
            <link>https://medium.com/@mfinkle/performance-the-merits-of-measuring-cf71c90a7539?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf71c90a7539</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Mon, 03 Jul 2017 19:31:55 GMT</pubDate>
            <atom:updated>2017-07-04T00:16:49.333Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6vLehxM7I4M_DbJ5NRprMw.png" /></figure><blockquote>If you can not measure it, you can not improve it. — Lord Kelvin.</blockquote><p>There is so much information out there on ways to improve the performance of your mobile application or website. You probably feel you can just dive in and start making changes. But if you’re not <em>measuring</em> your application’s performance, you don’t know if anything is really helping or hurting. How do you know what effect any changes will have on the performance? Most applications are complex enough that we can’t assume our simplistic reasoning accurately reflects the code behavior. You need to measure.</p><p>You need measurements from before and after any changes are made. Your application has development phases, so should your measurement plan. Measure in <a href="https://en.wikipedia.org/wiki/Continuous_integration">CI</a> to find improvements and regressions as soon as they happen. Measure in the <a href="https://en.wikipedia.org/wiki/Real_user_monitoring">real world</a> to find how variations like network conditions, device fragmentation, and unpredictable user behavior manifests in performance.</p><p><strong>Measuring in CI</strong></p><p>The point of measuring performance in CI is to control variability and watch for <em>relative differences</em> on each change. Try to reduce the noisy variables like network calls and background services to create a fast and consistent surface on which you can monitor performance changes in a reliable and repeatable manner. The purpose is not to determine the performance your users will encounter. There are too many variables in the real world and you can’t control them well enough for apples-to-apples comparisons.</p><p>Use real devices when measuring performance, not emulators or simulators running on host hardware.</p><p>You can try to create reliable &amp; repeatable simulations of some real world situations. Network connection speed is one example. You can use a network simulator, like Facebook’s <a href="https://facebook.github.io/augmented-traffic-control/">Augmented Traffic Control</a> system to simulate WiFi and mobile network conditions. This is especially useful if your application is designed to react differently under different network conditions. You can also use different types of content in the tests, trying to mimic some high level differences your users might encounter.</p><p>If you’re measuring data in CI, you should be storing and displaying it as well. Try to get the CI to alert on regressions, failing changes before they make it into the product.</p><p>Some common things to measure in CI:</p><ul><li>Launch time to show UI</li><li>Launch time to interactive UI</li><li>Scroll performance (janky frames)</li><li>Time to load content</li><li>Memory usage (startup, after content loads, after scrolling content)</li></ul><p>Remember to use multiple (physical) devices and a variety of content types.</p><p><strong>Measuring in Real World</strong></p><p>While CI measurements come from only a handful of tests &amp; situations, the real world has many, many more situations. Depending on the number of active users, you could have millions of data points with thousands of unique situations. Collecting data from real users, at a large scale, allows you to investigate how things like global regions, network conditions — and even user types — can affect the performance of the application.</p><p>The are many third-party systems you can integrate into your code to easily and efficiently collect real world data. It’s not uncommon for companies to grow their own systems as well. In any case, make sure you are validating the data itself. Since real world data is messy, make sure you are vetting the collection systems and the data. Look for problems like payload corruption, clock skew, range errors or other oddities.</p><p>Create automated queries and reports, sent out broadly for people to review. Remember to go deeper than high-level summaries. Some of the interesting discoveries happen when you split out data across different dimensions.</p><p>Some common things to measure from real world:</p><ul><li>Network usage, including start time, end time, content type and size of the response. Get detailed connection timing, if possible, for DNS and SSL handshake information.</li><li>For API endpoints, this is useful for tracking latency and payload size</li><li>For media loading, this gives a ballpark metric for how long people are staring at an empty box, waiting for an image to load.</li><li>Event, session and error state data. This can be used to track critical content impressions, but also can be used to learn how people use the application.</li></ul><p>Remember to include some common metadata in each measurement so you can split out the data across different dimensions. Things like non-<a href="https://en.wikipedia.org/wiki/Personally_identifiable_information">PII</a> identifier, generic geo-location/region, device specs and connection type/speed can help you drill down into the data, looking for trends.</p><p>It’s also polite to allow people to <em>opt-out</em> of this type of data collection.</p><p><em>Originally published at </em><a href="http://starkravingfinkle.org/blog/2017/07/performance-the-merits-of-measuring/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf71c90a7539" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guiding Teams to Outcomes]]></title>
            <link>https://medium.com/@mfinkle/guiding-teams-to-outcomes-34af15d40a66?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/34af15d40a66</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Tue, 27 Jun 2017 04:29:25 GMT</pubDate>
            <atom:updated>2017-07-03T19:31:10.227Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O-6mCxYPuTkWtxcuoWPXxQ.jpeg" /></figure><p>You work in an organization that sets some high-level goals. Your team might be accountable for some of those goals. However, to hit the goals, you’ll need cooperation from groups outside of your team.</p><p>What do you do? How do you get everyone on the path to finishing the shared outcomes?</p><p>Situations like this happen a lot. Some ideas:</p><ul><li>Make sure the path is clearly marked.</li><li>Make it easy for people to stay on the path.</li><li>Make it hard for people to go off the path.</li><li>Be the voice of encouragement.</li><li>Be the voice of recognition.</li><li>Assume people want to be on the path, but they might also be busy with other problems.</li></ul><p>Managing “friction” can be a useful technique in getting everyone working toward the goals. Try to reduce friction on anything that positively affects getting to the outcomes, but add friction to those things that are negative.</p><ul><li>Centralize documentation for checklist processes. Better yet, automate as many of the steps as possible. Even better might be to add the manual steps to your automated steps so you only have one true list.</li><li>Do more checks in your continuous integration (CI) system, especially adding automated tests (unit, integration and performance). Stop regressions ASAP.</li><li>Make sure the output of your process is being measured and is clearly visible to everyone. Put up monitors with charts and graphs in your open office spaces. Showing progress and trends helps to reinforce the importance of everyone’s role in hitting goals.</li><li>Add anomaly detection to the measurement data. Don’t count on people to find the problems in real-time.</li><li>Don’t be surprised if you need to keep repeating the plan.</li></ul><p><em>Originally published at </em><a href="http://starkravingfinkle.org/blog/2017/06/guiding-teams-to-outcomes/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34af15d40a66" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Communicating via IRC/Slack]]></title>
            <link>https://medium.com/@mfinkle/communicating-via-irc-slack-3f129a03f603?source=rss-82c69a028ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f129a03f603</guid>
            <category><![CDATA[team-building]]></category>
            <category><![CDATA[remote-working]]></category>
            <category><![CDATA[office-culture]]></category>
            <dc:creator><![CDATA[Mark Finkle]]></dc:creator>
            <pubDate>Mon, 16 Jan 2017 00:08:06 GMT</pubDate>
            <atom:updated>2017-07-03T19:30:05.712Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/672/0*qJSuvdpfupMGCLgH.jpeg" /></figure><p>I’ve used messaging tools like IRC and Slack at work every day for the last 11+ years. For much of that time, I was working remotely. Even my co-workers, working in offices, used messaging tools as much as I did.</p><p>When I first started working for Mozilla and visited one of the main offices, it was weird to see this happening. People sitting a few desks away from each other were chatting via messaging instead of just speaking. There are many reasons why this happens, but a primary outcome was that it allowed remote workers to be included in almost all discussions.</p><p>Spending so much time in messaging tools has downsides. Communicating efficiently via text-based messaging requires learning how to be a better communicator. Text-based messaging loses almost all the tone and nuance of a spoken conversation. A lot of context and expression happens via non-verbal communication. That is missing from text-based messaging and it can lead to communication problems.</p><p><strong>Assume people are generally good:</strong> It’s easy to read something and assume the worst. This generally doesn’t end well.</p><ul><li>You’re disrupting a person’s workflow. You don’t know what they are doing or their mood. Be gentle, not demanding.</li><li>When things start to get complicated, confusing or heated, switch to face-to-face or video chat.</li><li>Make your intent clear. When people are left to infer, things can go poorly. For example:</li><li>me: Is your project almost finished? them: (is he asking for status or thinking I’m too slow?)</li></ul><p><strong>Be careful delivering critical feedback:</strong> Giving someone feedback can be tricky in face-to-face conversations. Over text messaging, it can be dangerous. It’s easy for feedback to be seen as a personal attack.</p><ul><li>Use questions, not statements. This encourages more discussion and doesn’t put people on the defensive as much.</li><li>Use examples of your own failures. Show you know people make mistakes.</li><li>Focus on the outcome, not the current implementation. Are we getting to the outcome we want?</li><li>Use ‘we’ instead of ‘you’ when possible. We are in this together.</li></ul><p><strong>Be ready to moderate:</strong> Sometimes people aren’t on the same page. If you see a conversation getting heated, try to diffuse it. It’s important to keep communication channels as a ‘safe space’ for everybody.</p><ul><li>Use private channels to let people know a conversation is off-track. People can be unaware how badly things have become.</li><li>Be public when needed. Other people in the channel will benefit from knowing the limits of unacceptable behavior.</li><li>Moderation is a form of critical feedback. See above.</li></ul><p><strong>Not everyone will get the joke:</strong> Using humor over text-based messaging can backfire. Trying to be funny can lead to situations where no one is laughing, or even worse, people could be offended. Use caution.</p><p><em>Originally published at </em><a href="http://starkravingfinkle.org/blog/2017/01/communicating-via-ircslack/"><em>stark raving finkle</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f129a03f603" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>