<?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 KJ Jones on Medium]]></title>
        <description><![CDATA[Stories by KJ Jones on Medium]]></description>
        <link>https://medium.com/@KJ.Jones?source=rss-c84dfc3a2036------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*J0hGBY4AniiZauzj4ksVlQ.jpeg</url>
            <title>Stories by KJ Jones on Medium</title>
            <link>https://medium.com/@KJ.Jones?source=rss-c84dfc3a2036------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 23:44:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@KJ.Jones/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[Complete Guide to Unit Testing Durable Functions with VS Code]]></title>
            <link>https://medium.com/hackernoon/complete-guide-to-unit-testing-durable-functions-with-vs-code-46d343789c75?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/46d343789c75</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[azure-functions]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Thu, 15 Nov 2018 14:32:53 GMT</pubDate>
            <atom:updated>2018-11-28T22:15:30.804Z</atom:updated>
            <content:encoded><![CDATA[<h4>Dependency Injection, Code Coverage, Debugging &amp; More</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8RNsWU6QnZc8DyeKOjSlvg.png" /></figure><p>I love VS Code. I also love Azure Durable Functions. And unit testing is pretty sweet. Put them all together and you get… somewhat unchartered territory.</p><p>Most .NET Core 2 unit testing principles apply to Durable Functions, but there a few additions. Especially if you are only running Visual Studio Code. This should get you started with:</p><ul><li>Project Setup</li><li>Packages &amp; Extensions</li><li>Dependency Injection and Azure Functions</li><li>Testing Durable Functions</li><li>Running Tests</li><li>Code Coverage</li><li>Debugging Unit Tests</li></ul><h3>Project Setup</h3><p>.NET unit tests should be in their own directory with their own project, all part of the entire solution. Assuming you already have some code to test in a src directory, follow these steps to setup your test directory:</p><ol><li>Create a new directory to house unit tests. test is probably a good name.</li><li>Create a unit test project<br>a. Move to the test directory<br>b. Run dotnet new mstest (Creates a new unit test project using MSTest) You could also pass NUnit or xUnit.<br>c. Add the main project(s) to this testing project - dotnet add reference ../src/MyProject.csproj</li><li>Move back to the root directory and add the unit test project to the solution — dotnet sln add test/MyProject.Tests.csproj</li></ol><h3>Packages &amp; Extensions</h3><p>You’ll want to install the following packages into the <strong>unit test</strong> project.</p><ul><li><a href="https://www.nuget.org/packages/moq/">Moq</a> — For mocking and stubbing.</li><li><a href="https://www.nuget.org/packages/coverlet.msbuild/">Coverlet</a> — For cross platform code coverage</li></ul><p>Also recommended are the following VS Code extensions:</p><ul><li><a href="https://marketplace.visualstudio.com/items?itemName=formulahendry.dotnet-test-explorer&amp;WT.mc_id=-blog-scottha">.NET Core Test Explorer</a> — A UI for running tests</li><li><a href="https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters&amp;WT.mc_id=-blog-scottha">Coverage Gutters</a> — Display covered lines of code right in VS Code.</li></ul><h3>Dependency Injection and Azure Functions</h3><p>Because of the static nature of Azure Functions, they do not currently support dependency injection (DI). This is an issue as DI is imperative to unit testing in C#. Fortunately, there are ways to implement DI. This is the easiest I&#39;ve found.</p><ol><li>Install <a href="https://www.nuget.org/packages/Willezone.Azure.WebJobs.Extensions.DependencyInjection">this</a> package which “contains binding extensions for dependency injection”.</li><li>Create a file in the root of the <strong>main</strong> project called Startup.cs with these contents:</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/701c2f4522a901c0fcc5d469df7965a4/href">https://medium.com/media/701c2f4522a901c0fcc5d469df7965a4/href</a></iframe><p>3. This works very similar to a normal .NET Core project, where you can add singleton references in a startup file.</p><p>4. Notice that ConfigureServices is where you instantiate your abstract functions or interfaces. In the above example, we create an instance of the ISendGridClient (for sending emails). We then add it as a singleton and now anytime an ISendGridClient is Injected, this instance will be passed in.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/56bffa42489b5a6e55437ca8463585c6/href">https://medium.com/media/56bffa42489b5a6e55437ca8463585c6/href</a></iframe><p>5. Now unit tests can pass in their own mocks of the class like normal:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f7a9ebc581d8a0905a4aeeee5da845e9/href">https://medium.com/media/f7a9ebc581d8a0905a4aeeee5da845e9/href</a></iframe><p>Note: There is a known <a href="https://github.com/Azure/azure-functions-host/issues/3386#issuecomment-419565714">issue</a> where this will throw errors in Azure. There’s a workaround that’s worked for me, per the docs. Put this <a href="https://github.com/BorisWilhelms/azure-function-dependency-injection/blob/master/tools/Directory.Build.targets">Directory.Build.target</a> file in the root of your function app. This will copy over the missing file in Azure.</p><h3>Testing Durable Functions</h3><p>Durable functions are pretty unique in the C# world. So it should be expected that testing them is pretty unique as well. Any normal function in a Durable Function project can, of course, be tested like normal. For those specific to Durable Functions, follow these steps. See <a href="https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-unit-testing">this</a> article from Microsoft for more info.</p><h4>Starters</h4><p>You should append Base to the DurableOrchestrationClient parameter.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/44b330e7b2e793a3ed3529b7bf432f13/href">https://medium.com/media/44b330e7b2e793a3ed3529b7bf432f13/href</a></iframe><p>This DurableOrchestrationClientBase class can now be mocked and then passed directly to the starter function.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22e0e074fd45151d8581308cfe45d8b6/href">https://medium.com/media/22e0e074fd45151d8581308cfe45d8b6/href</a></iframe><p><strong>HTTP Starters</strong></p><p>HTTP starters have an HttpRequestMessage parameter, which is not easy to mock (at all)! See an example TestHelper file that does the necessary setup in <a href="https://gist.github.com/KevinDJones/f9dce0e790ff2784ec3aba4aaf8a8353">this Gist</a>.</p><p>Once you have the SetupHttp function, you can use it as follows in this complete example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/93a1274d107c3c2d5bc34b64d9444457/href">https://medium.com/media/93a1274d107c3c2d5bc34b64d9444457/href</a></iframe><h4>Orchestrators</h4><p>You should append Base to the DurableOrchestrationContext parameter.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/49d8a7e50106999699d15afd09fa1e63/href">https://medium.com/media/49d8a7e50106999699d15afd09fa1e63/href</a></iframe><p>This DurableOrchestrationContextBase class can now be mocked and then passed directly to the orchestrator function.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c926beb57b41e9e8472b40e4e1afe30b/href">https://medium.com/media/c926beb57b41e9e8472b40e4e1afe30b/href</a></iframe><h4>Activities</h4><p>Activities can be tested just like any other .NET function. You can just pass the parameter as you normally would, despite the ActivityTrigger decorator</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ccb30f175b8350bf2bd2f4bcb9111a9/href">https://medium.com/media/3ccb30f175b8350bf2bd2f4bcb9111a9/href</a></iframe><p>You can simply pass the MyClass model in directly as normal. If you happen to be using DurableActivityContext instead of a model directly, like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a5f99657c7e93629cf34634b4a8b6f29/href">https://medium.com/media/a5f99657c7e93629cf34634b4a8b6f29/href</a></iframe><p>There is currently no Base class that can be mocked. But that is currently in the <a href="https://github.com/Azure/azure-functions-durable-extension/pull/494">dev branch</a> of Durable Functions. Ensure thatDurableActivityContext is needed, you may be able to just use the model directly. If not, tough 😃. It’s coming!</p><h3>Running Tests</h3><p>Once you’re in your testing directory, dotnet test is the easiest way to run your tests. You can also run dotnet watch test and tests will re-run every time you change a file.</p><p>If you don’t like typing, you can create a task in VS Code. Open up tasks.json and add the following JSON snippet. Be sure to replace the MyProject stuff with the the location of your project.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a9ddd8fd50035c61dc3b586da1f8f973/href">https://medium.com/media/a9ddd8fd50035c61dc3b586da1f8f973/href</a></iframe><p>Then you can open the VS Code command palette and run “Tasks: Run Test Task”</p><h3>Code Coverage</h3><p>Code coverage is built into .NET Core, but doesn’t work great cross platform. We’ll use the Coverlet package we installed earlier instead. To run a test with code coverage enabled, you can run dotnet test /p:CollectCoverage=true.</p><p>The Coverage Gutters extension we installed earlier can show covered lines right in VS Code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*oZi0UVaMmPUhpImQ_BYsHw.png" /><figcaption>Taken from <a href="https://www.hanselman.com/blog/AutomaticUnitTestingInNETCorePlusCodeCoverageInVisualStudioCode.aspx">Scott Hanselman’s</a> Article on Coverage Gutters</figcaption></figure><p>This requires a specific file format. To create the correct file format, run this really short command:</p><p>dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=lcov /p:CoverletOutput=./lcov.info</p><p>This simply tells dotnet to collect coverage and create it in lcov format, which Coverage Gutters requires. Then you can use the command palette and either run &quot;Coverage Gutters: Display Coverage&quot; or &quot;Coverage Gutters: Watch&quot;. Watch is cool because it automatically updates as tests are added. Combined with dotnet watch test, it&#39;s all pretty nice and automated.</p><h3>Debugging Unit Tests</h3><p>Debugging is fun and necessary. It doesn’t play too well with all of the above fun stuff, but it’s still doable.</p><p>First, you need a debug command to attach to a process. Open launch.json and add a new configuration:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/914a76590ffcb715d94ab3e83f13d307/href">https://medium.com/media/914a76590ffcb715d94ab3e83f13d307/href</a></iframe><p>This will let you attach the VS Code debugger to any process. Let’s get VS Code ready for that.</p><ul><li>Run the command export VSTEST_HOST_DEBUG=1. This tells VS code to get ready to do some debugging.</li><li>Run dotnet test</li><li>Rather than running the tests, it will wait for you to attach to the process:</li></ul><pre>Host debugging is enabled. Please attach debugger to testhost process to continue.<br>Process Id: 60143, Name: dotnet</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/796/1*nRF33zCpYSXbrgyMj0RLUQ.png" /></figure><ul><li>Run your .NET Core Attach command from the debug tab. Pick the process ID that was shown earlier (60143 in this example).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*l0tQFmrWi3UNTRHhmrO_2w.png" /></figure><ul><li>Almost there. All of this gets you connected, but not quite into your tests yet. Over in the “Call Stack” tab, you should see something that says “&lt;No Name&gt; Paused On Breakpoint”</li><li>Click “Paused on Breakpoint” now you can hit Continue in the debugger, and you should be taken to the first breakpoint that you set!</li><li>When you figure out your problem, you can run export VSTEST_HOST_DEBUG=0 to go back to normal.</li></ul><h3>Conclusion</h3><p>That’s it! Hopefully you found this helpful. There’s a bit to it, but with a little bit of setup you can do just about anything you’d want to do in VS Code to unit test Durable Functions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46d343789c75" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/complete-guide-to-unit-testing-durable-functions-with-vs-code-46d343789c75">Complete Guide to Unit Testing Durable Functions with VS Code</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Solving Serverless Cold Starts with Advanced Tooling]]></title>
            <link>https://medium.com/hackernoon/serverless-cold-starts-using-them-to-your-advantage-3dfdf9a0bc66?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/3dfdf9a0bc66</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[azure-functions]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[serverless]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Wed, 07 Nov 2018 15:35:11 GMT</pubDate>
            <atom:updated>2018-11-07T19:56:39.092Z</atom:updated>
            <content:encoded><![CDATA[<h4>Taking one of the biggest downsides of serverless and making it work for you.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*t1WbtVi4w6Wm2J84" /><figcaption>Photo by <a href="https://unsplash.com/photos/WUNToVtzhik?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Jonathan Percy</a> on <a href="https://unsplash.com/search/photos/ice?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><h3>What are Cold Starts?</h3><p>If you spend a lot of time building serverless functions, you might start to think they’re too good to be true. The code is easier to manage and maintain. Azure’s Durable Functions set you up for success by giving you complicated plumbing right out of the box. Plus, they’re <em>absurdly</em> cheap.</p><p>The inner skeptic inside of me has been wondering, what’s the catch? Something has to give. No doubt, serverless is not a perfect world, and there are certainly downsides to consider. And one of the biggest downsides is that of cold starts.</p><blockquote>Cold start is a term used to describe the phenomenon that applications which haven’t been used a while take longer to start up. (<a href="https://blogs.msdn.microsoft.com/appserviceteam/2018/02/07/understanding-serverless-cold-start/">MSDN</a>)</blockquote><p>The above MSDN article does a great job of explaining what cold starts are, how they work, and why they’re necessary. To help keep costs low, a serverless app that has been idle for some period of time gets deallocated. This means a user’s first call to a deallocated function may have a delay while the function loads.</p><p>Cold starts work a little different in each serverless environment (Azure, AWS, Google Cloud). But the concept is the same. <a href="https://mikhail.io/">Mikhail Skilkov</a> has a great series of articles on cold starts. This <a href="https://mikhail.io/2018/08/serverless-cold-start-war/">one</a> compares cold start behaviors in each platform.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iqYEC2tMlyKx15pH.jpg" /><figcaption>What Happens During a Cold Start (From <a href="https://blogs.msdn.microsoft.com/appserviceteam/2018/02/07/understanding-serverless-cold-start/">MSDN</a>)</figcaption></figure><p>Let’s face it, for most applications, the cold start problem is more of a minor inconvenience. A rare and occasional delay of a few seconds isn’t too big of a deal for most apps. But for some use cases, it could be an absolute deal breaker. So what can we do?</p><h3>Solutions</h3><p>The general consensus is that to reduce cold starts, you make sure your app never goes “cold” in the first place. This is usually done by creating a separate function that makes a request to your app every X minutes. I’ll propose a very similar pattern, but one that could provide some added business value.</p><h4>A Timer Function App</h4><p>The tried and true approach is to create a separate function app that works on a timer. You set the timer to run at some interval that you know your app will not be cold. Azure Functions, for example, “deallocate resources after roughly 20 minutes of inactivity<a href="https://blogs.msdn.microsoft.com/appserviceteam/2018/02/07/understanding-serverless-cold-start/">*</a>”.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/733ff31441d4a60997b48a7752ca0d57/href">https://medium.com/media/733ff31441d4a60997b48a7752ca0d57/href</a></iframe><p>So it may be good to set the timer to run every 15 minutes to ensure the app never goes cold. Or more often to be sure! Once again, I’ll link to Mikhail Skilkov. He has another <a href="https://mikhail.io/2018/05/azure-functions-cold-starts-beyond-first-load/">great article</a> showing the effectiveness of this approach. It’s not perfect, but it’s a great alternative to rolling the dice and hoping your users aren’t affected by cold starts.</p><h4>A Third Party Monitor</h4><p>If cold starts are a real problem, then this is a pretty mission critical application. And for those apps, you need all the assurance you can get that your app is not only performing well, but is performing in the first place.</p><p>Serverless functions have pretty high uptimes. Azure will give you some credits if it dips below a <a href="https://azure.microsoft.com/en-us/support/legal/sla/functions/v1_0/">99.95% uptime</a> for functions. But that’s not to say they never go down, or slow down. And for mission critical apps, a small downtime can cost a lot. Getting alerts, even if it’s only down for a few minutes, is a big win.</p><p>That’s where API monitoring tools like <a href="https://www.runscope.com/">RunScope</a> and <a href="https://assertible.com/">Assertible</a> come into play. These services let you setup schedules to hit your APIs at some interval. They can run tests on the results and alert you if anything is out of whack. This is a perfect cold starter!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*tSl7t_qtoNBXAYfwL-ZF1w.png" /><figcaption>RunScope Scheduler</figcaption></figure><p>It’s the same concept as your own function app, but comes with added benefits. For one, there’s a separation of concerns. If your function app is down, the cold starter function (that’s also down) isn’t going to help you much. This gives you an unbiased third party ensuring everything is working appropriately.</p><p>You can also get a view of how performant your function is over time. Now that you’re testing your app so often, you’ll start to see patterns. Is the app getting slower? Has a new feature increased load times? Can we be sure there aren’t cold start issues in production?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*TRgPnGeY2--nQd_I6AGsGw.png" /><figcaption>RunScope’s Test Dashboard</figcaption></figure><p>I have no affiliation, but I’ve always been a big fan of <a href="https://www.runscope.com/">RunScope</a>. And I’d highly recommend it not just cold starting your function apps, but for all your API monitoring. The above overview is pretty nice to have. Plus, responding to dips (like on October 10 in the graph) based on RunScope alerts instead of angry users is priceless.</p><p>That said, $79/month for the cheapest plan may be a bit much if you’re only cold starting. <a href="https://assertible.com/">Assertible</a> is another nice option that even has a free plan to get going. You can make requests as often as every 30 minutes with the free tier. It’s not quite often enough to eliminate cold starts, but it could decrease the frequency your users experience them. Plus you get all the other benefits. If you find your users are still having issues, you can upgrade to a more reasonable plan. The $25/month plan will let you run every five minutes or faster. Perfect for keeping those function apps warm.</p><h3>Wrap Up</h3><p>Whatever you choose to do, it’s clear that the cold start issue deserves some thought as you go serverless. There’s no doubt that Azure is working on improving cold start performance. There was a time where it was every five minutes, now we’re up to ~20. But until the problem is gone, do yourself (and your users) a favor and keep the apps warm. You may even benefit from it in the process.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3dfdf9a0bc66" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/serverless-cold-starts-using-them-to-your-advantage-3dfdf9a0bc66">Solving Serverless Cold Starts with Advanced Tooling</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Durable Function Recipe — Webhooks Made Easy]]></title>
            <link>https://medium.com/hackernoon/durable-function-recipe-webhooks-made-easy-4878b1972417?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/4878b1972417</guid>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Tue, 30 Oct 2018 05:52:58 GMT</pubDate>
            <atom:updated>2018-10-30T18:56:58.173Z</atom:updated>
            <content:encoded><![CDATA[<h3>Durable Function Recipe — Webhooks Made Easy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rH1PRA1-14K_93QLvt3shA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/NYDTneTcSdo?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Johannes Plenio</a> on <a href="https://unsplash.com/search/photos/webhook?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Handling webhooks is a very common pattern in backend development. You call a third party API, and the API immediately returns successfully. Then the third party does something nifty like sending a message, or using a neural network. and when it’s done, it calls <em>your</em> API with the results.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*gj7Uh-9K0udWSN9N1CJdew.png" /></figure><p>It’s a pretty straightforward pattern that makes a whole lot of sense on paper. But it can get complicated in practice. Once you’ve called the API, you’ve completely lost state. When the service calls your webhook, you need to figure out which of your entities it’s talking about. And then you need to recreate the state it was in before calling the API. This generally involves a lot of calls back to your database to recreate what you had seconds ago.</p><p>I’ve built countless webhook handlers over the years. I felt like I had optimized the webhook pattern as much as possible. <em>And then I built one with Azure Durable Functions.</em></p><p>If you’re new to Durable Functions, see my <a href="https://hackernoon.com/durable-functions-backend-development-made-easy-and-cheap-cbab7acc7050">initial impressions</a> or Microsoft’s <a href="https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-overview">overview</a>. Basically, you define workflows in code, all while enjoying the benefits of serverless.</p><h3>Durable Function Webhooks</h3><p>For webhooks, the <a href="https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-phone-verification">human interaction</a> pattern is what we’ll use. This pattern involves:</p><ul><li>Executing some number of actions</li><li>Waiting an arbitrary amount of time for some external event (often a human) to be raised.</li><li>Continuing execution.</li></ul><p>In this case, the external event will be a webhook. This recipe is going to involve sending an SMS message using the popular Twilio service. After sending a message, Twilio can respond back with the delivery status. For example, you may want to do some business logic if a message failed to send.</p><p>I’ve build Twilio handlers in many languages for many use cases. But Durable Functions make it the easiest by far. It usually goes something like this:</p><p>I’ve got all sorts of information about the person I’m about to send a message to. I send the message, mark down a unique message ID that Twilio gives me, and that’s it. Everything is gone. Now I wait.</p><p>Some time later (usually within seconds), Twilio hits my API with a unique message ID. This is generally in a completely separate part of the app. I use the ID to lookup the message, and now I’ve got to recreate everything I had before sending to Twilio. But I <em>just</em> had it! It may not seem like much, but at scale, all of these trips back to the data store really add up.</p><p>In Durable Functions, the webhook logic happens <strong>one line</strong> after sending the message. Let’s see how it works.</p><iframe src="https://cdn.embedly.com/widgets/media.html?url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D0XvXwVn_AnQ&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F0XvXwVn_AnQ%3Ffeature%3Doembed&amp;type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/74252a93f247f5baaacd2bad7b064e30/href">https://medium.com/media/74252a93f247f5baaacd2bad7b064e30/href</a></iframe><h3>Getting Setup</h3><p>I’ll be running VS Code on a Mac, but this will work in any OS. We’ll start by using the <a href="https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions">Azure Functions</a> extension in VS Code to create a new C# function project in an empty directory.</p><p>We’ll then need some packages. Run these commands to get the extensions for Durable Functions, Azure Table Storage, and Twilio.</p><p>dotnet add package Microsoft.Azure.WebJobs.Extensions.DurableTask --version 1.6.2<br>dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage --version 3.0.1<br>dotnet add package Microsoft.Azure.WebJobs.Extensions.Twilio --version 3.0.0</p><p>Create a Models directory and file called MessageInput.cs in it. This will contain the properties needed to send a message:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2b1f17c25f2545842b02c206d6477a10/href">https://medium.com/media/2b1f17c25f2545842b02c206d6477a10/href</a></iframe><h3>The Starter</h3><p>We need some way to start the sending of a message. We’ll use an HTTP trigger. If you’re not familiar with Durable Functions, you can ignore the function parameters.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b7761e6a6dc8dc6209c9b2849908e8d5/href">https://medium.com/media/b7761e6a6dc8dc6209c9b2849908e8d5/href</a></iframe><p>We read the body (as a MessageInput object that we created earlier) and pass it to an orchestrator to start the workflow. Then we return with the orchestration status. That’s it! Now we need to create an orchestrator.</p><h3>The Orchestrator</h3><p>This is where the real magic happens. The entire workflow for sending a message and getting its response happens in five lines of code.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/df29e4a5c734f5d7bb9ea1a5282a2204/href">https://medium.com/media/df29e4a5c734f5d7bb9ea1a5282a2204/href</a></iframe><p>Each orchestration has a unique ID. This ID should generally be kept secret, so we’ll create a mapping that maps the orchestration ID to a unique ID. We’ll send the unique ID to the third party, and when they give it back to us, we’ll use it to lookup the orchestration ID.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*cL85TxMc8M2LYcU55zZLkg.png" /></figure><p>We send the message, and then call WaitForExternalEvent. This pauses the orchestration indefinitely until the TwilioCallback event is fired. At this point, we’ll have the status and can continue with our business logic.</p><h3>The Activities</h3><h4>Creating a Mapping</h4><p>We’ll use Azure Table Storage (which Durable Functions use anyway) to save our mapping. Azure Functions support a <a href="https://docs.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-table">Table Binding</a> which allows you to pull data out of the database with little code.</p><p>We need a class to hold the mapping:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/72ae3c0c3233506cb4aa81e43657a9f0/href">https://medium.com/media/72ae3c0c3233506cb4aa81e43657a9f0/href</a></iframe><p>Table Storage needs a PartitionKey and a RowKey. We’ll save the OrchestrationId and use the RowKey to send to Twilio, and to find our orchestration again.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1339544da48306782c0859fac9ec01e3/href">https://medium.com/media/1339544da48306782c0859fac9ec01e3/href</a></iframe><p>This function simply saves the mapping to Table Storage and returns the RowKey for later use. We get to use the Table binding to specify which table we’re interested in in the function parameters.</p><h4>Sending a Message</h4><p>Azure functions also support <a href="https://docs.microsoft.com/en-us/azure/azure-functions/functions-bindings-twilio">Twilio Binding</a>s, which send SMS messages with little code. Here, we create a CreateMessageOptions object and populate it with the inputted number.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f5c7c3bc95b11f7d539e6f4b1b31dac/href">https://medium.com/media/1f5c7c3bc95b11f7d539e6f4b1b31dac/href</a></iframe><p>The StatusCallback, is the URL Twilio will hit to give us the message’s status. We include the RowKey in the URL to lookup our mapping. We’ll create that route next.</p><h4>Webhook Handler</h4><p>The last thing to do is handle when Twilio responds back to our API with the status. This, of course, is just another HTTP triggered function. The function parameters aren’t much different than the last HTTP function.</p><p>The only difference is it uses the Table binding to lookup the ID that Twilio passed back. This returns a record with the orchestration ID, which means we can now raise an event to that orchestration.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/079c54ed46a65756c06bbf17bcbadc85/href">https://medium.com/media/079c54ed46a65756c06bbf17bcbadc85/href</a></iframe><p>If you’ll recall, the orchestrator is currently waiting for a TwilioCallback event to fire, so let’s keep it waiting no more! We pass in the status and the orchestration can resume <em>right</em> where it left off.</p><p><em>Note: Azure functions currently do not support x-www-form-urlencoded responses, which is what Twilio provides. </em><em>ParseForm handles this for us. See the </em><a href="https://github.com/KevinDJones/DF_Webhook/blob/master/Starters.cs#L47"><em>full code</em></a><em> for details.</em></p><h4>Conclusion</h4><p>That’s it! Five functions to send messages <em>and</em> handle callbacks. Best of all, we can pick up <em>right</em> where we left off before we started waiting for the webhook. No more duplicate trips back to the database. It’s the cleanest way to implement webhooks that I’ve experienced.</p><p>Check out the <a href="https://github.com/KevinDJones/DF_Webhook">full code</a> or the video above for the full details!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4878b1972417" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/durable-function-recipe-webhooks-made-easy-4878b1972417">Durable Function Recipe — Webhooks Made Easy</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Durable Functions — Backend Development Made Easy (And Cheap!)]]></title>
            <link>https://medium.com/hackernoon/durable-functions-backend-development-made-easy-and-cheap-cbab7acc7050?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/cbab7acc7050</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Thu, 18 Oct 2018 14:48:21 GMT</pubDate>
            <atom:updated>2018-10-30T05:51:33.573Z</atom:updated>
            <content:encoded><![CDATA[<h3>Durable Functions — Backend Development Made Easy (And Cheap!)</h3><h4>Thoughts on the new Serverless.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/0*8_lbGJG3lpfeGhyj.png" /><figcaption><a href="https://docs.microsoft.com/en-us/azure/azure-functions/durable-functions-overview#pattern-2-fan-outfan-in">Fan-Out/Fan-In Pattern</a></figcaption></figure><p>Going serverless with function apps has been quite enticing for some time. Not having to pay for 24/7 infrastructure, but getting complete auto-scaling is a game changer. But it’s never felt like serverless functions could replace your stack. Is it good for a simple Slack app? Sure. But not a complex backend. Until now.</p><p>Azure’s Durable Functions extend their already established Functions as a Service (FaaS) platform. Finally, serverless functions have state. You define workflows in code, all while enjoying the many benefits of serverless.</p><p>In many ways, Durable Functions feel like the way serverless functions were meant to be. And Azure is the only cloud provider currently offering such a tooling. Durable functions let you chain functions together. You can even run them in parallel, and easily track workflow progress. There are robust error handling and retry mechanisms that you get right out of the box.</p><p>After building a handful of proof of concepts, I was sold. It was time to refactor some production applications, as well as start a couple from scratch. Here’s what I’ve found so far.</p><h3>More Coding, Less Plumbing</h3><p>I’ve worked on a lot of larger scale Node.js applications with varying use cases. But it seems that no matter what, there is some sort of queue processing needed, and that’s where I spend most of my time.</p><p>Sure, there are great frameworks out there like <a href="https://github.com/Automattic/kue">Kue</a> and <a href="https://github.com/OptimalBits/bull">Bull</a> that do a lot of the heavy lifting for you. Look at those readme’s though. There is a lot of setup, and even more work to troubleshoot and maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XOjR0y4F2xMBkA6q0v1kCg.jpeg" /><figcaption>That’s Enough Plumbing for Me. (<a href="https://unsplash.com/photos/Md9UK7frBv0?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Damon Lam</a> on <a href="https://unsplash.com/search/photos/plumbing?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a>)</figcaption></figure><p>Durable Functions use a lot of the same mechanisms under the hood, but it’s all handled for you. This is a bit scary at first. Especially coming from a world where queue management was the source of most of my problems. But Azure has a much better solution, without the need to babysit every last transaction.</p><p>This has significantly increased output. I recreated functionality in hours what had taken days to do myself. Recurring tasks, automatic retry policies, and scheduled jobs just work. And if you have to troubleshoot, everything is queryable in Table Storage. No more need to parse through Redis keys. I can focus on business logic, instead of worrying about scheduled jobs.</p><h3>Super Easy Hosting</h3><p>Hosting is, of course, a breeze for large scale enterprise apps. But I don’t see myself using traditional hosting for my personal projects anymore. No longer do I have to struggle through the potato CPU and 128 bytes of RAM that the free hosting tiers provide. Or monthly fees to keep up a demo application.</p><p>Heck, if you need something up quickly, you don’t even need a GitHub repository or an IDE. I’ve already used the online code editor in Azure to host a couple demo functions for testing purposes. I now have my own servers I can host anything, at any time. And I don’t have to pay a dime.</p><h3>Still on the Cutting Edge</h3><p>While developing Durable Functions has been a good experience, there are issues. Everything is still pretty new and there is a lot of active development going on.</p><h4>Tooling Issues</h4><p>I’ve spent most of my time developing Durable Functions on a Mac. Don’t get me wrong, as a .NET developer for years, it’s a treat to be able to build .NET apps anywhere. But some things just don’t work right.</p><p><a href="https://github.com/azure/azurite">Azurite</a>, a local Azure Storage simulator for Mac/Linux, straight up doesn’t work. Theres a different simulator for Windows that works great. But Azurite isn’t durable yet. This means I’m incurring (minimal) costs doing local development. I have to use Azure Storage.</p><p>The recommendation is to use the <a href="https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions">Functions extension</a> for VS Code. But that is not quite durable either. It doesn’t setup projects the recommended ways. And it doesn’t seem to even know that Durable Functions are a thing yet. So I find myself creating functions from scratch rather than using the tool as intended.</p><h4>Language Options</h4><p>Durable Functions promise support for C#, JavaScript, F#, Java, and even more on the way. This is great news. It means that once you learn the Durable Functions patterns, you aren’t locked into a language choice.</p><p>Unfortunately, I’ve found that C# is the only valid option for right <em>now</em>. It is the only language that is “Generally available (GA) — Fully supported and approved for production use.” Azure Functions have more languages in GA. So it’s safe to say Durable Function support is coming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/659/1*o3eqfwYS_E1dPsn7XzmNQQ.png" /><figcaption>Supported Languages for Azure <em>Functions, But Not Durable (</em><a href="https://docs.microsoft.com/en-us/azure/azure-functions/supported-languages#languages-in-runtime-1x-and-2x"><em>Source</em></a><em>)</em></figcaption></figure><p>JavaScript is missing key implementations that make Durable Functions great. There is still a lot of stuff that doesn’t work. And the documentation is not even close to that of its C# counterpart. I found the development experience for JavaScript very frustrating. It was the opposite for C#.</p><p>I suspect Microsoft will address these issues whenever JavaScript becomes GA. Yet, it does seem C# will always be the preferred child.</p><blockquote>“JavaScript support generally has dependencies on our .NET implementation.” -<a href="https://github.com/MicrosoftDocs/azure-docs/issues/16118#issuecomment-427900886">Chris Gillum</a>, Principal Software Engineer on Durable Functions.</blockquote><p>That’s not to say it won’t be usable, but something to keep in mind when making a language decision. Even in the JavaScript apps I’m refactoring using Durable Functions, C# is the language choice. JS just isn’t there yet.</p><h3>Drastic Cost Decrease</h3><p>The most obvious advantage of serverless in general is the cost savings. You only pay while the functions are being consumed. This is huge, especially if you aren’t Twitter and don’t have a ton of traffic at all hours of the day.</p><p>Durable Functions add a touch more cost, as they use Azure Storage <em>a lot</em> to keep everything, well, durable. Still, that cost is minimal. Much better than hosting your own Redis instance to mimic functionality.</p><p>I’m not sure how Azure is making money on these things. The average web app would never come close to having any significant cost. But I figure it’s a way for them to get developers to start using the platform. It’s <em>awfully </em>easy to start using something like <a href="https://docs.microsoft.com/en-us/azure/azure-functions/functions-bindings-cosmosdb-v2">CosmosDb</a> with functions, and that is <em>not</em> cheap.</p><h3>Give it a Try</h3><p>All in all, the Durable Functions framework is an incredible tool. It has changed my mindset on how backend development can work. So give it a try! It’s free and easy to get going. You don’t even need an IDE, you can build out proof of concepts straight from the <a href="https://azure.microsoft.com/en-us/services/functions/">web portal</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cbab7acc7050" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/durable-functions-backend-development-made-easy-and-cheap-cbab7acc7050">Durable Functions — Backend Development Made Easy (And Cheap!)</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Speed Dating Your Way to a Better Tech Job]]></title>
            <link>https://medium.com/hackernoon/speed-dating-developers-75806fa15875?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/75806fa15875</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[job-interview]]></category>
            <category><![CDATA[hackerx]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Mon, 14 Aug 2017 14:29:10 GMT</pubDate>
            <atom:updated>2017-08-16T20:35:24.997Z</atom:updated>
            <content:encoded><![CDATA[<h4>Tips from an interviewer at HackerX</h4><blockquote>“Don’t hire the guy ahead of me, he’s a racist!”</blockquote><p>This was one of the many interesting quotes of the evening. I recently was an interviewer at <a href="https://medium.com/u/303d3872ee12">HackerX</a>, an invite-only recruiting event for developers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fyk-iWKkAID5lw9i0uhMqQ.jpeg" /><figcaption><a href="http://www.hackerx.org/">HackerX</a></figcaption></figure><p>The premise is simple. Hundreds of developers flood into a room with 15–20 companies and “speed date”. You get 4–5 minutes with each company and then you move on. It’s an interesting concept that helps both companies and developers to see what’s out there.</p><p>For developers, this is one of the quickest and easiest ways to get in front of top tech companies. HackerX boasts Google, Twitter, and Uber as past companies. In practice, it all depends on location. I hadn’t heard of any of the brands at the event I attended.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K8HefnA92I-ZardDIjQiIw.png" /></figure><p>For companies, the pitch is that each developer was hand picked by the event coordinators. There is a generally a specific focus too. Our event was for full-stack developers with 5+ years experience.</p><p>I spoke to over 30 developers that night. I reached out to two. And I currently work with zero. It was a bust. All in all though, HackerX did a good job organizing the event. There was free food and beer. The fast-paced interviewing ran like clockwork. The developers just kinda sucked.</p><p>At least, they interviewed that way. Understandable, since this was a new experience for everyone in the room. As an interviewer, I saw many strategies that developers took. It didn’t take learn to learn which were successful. If I were to attend as a candidate, these are some of the things I would focus on.</p><h3>Make a Positive First Impression</h3><p><a href="http://www.dailymail.co.uk/sciencetech/article-2661474/First-impressions-really-DO-count-Employers-make-decisions-job-applicants-seven-minutes.html">Research</a> shows that you have six minutes and 25 seconds to make a solid first impression in a <a href="http://42hire.com/tagged/job-interview">job interview</a>. While first impressions are hard to shake, at least with a real interview you get that chance. Here, first impressions aren’t just important, they’re everything. Make it count. Don’t call people racists (yes, this happened).</p><p>A staggering number of candidates spent too long complaining about their current situation. Why their company was wronging them and how much better they are than that. They focused on everything negative.</p><p>After all the pleasantries, you’ve got about 240 seconds to impress. Take a minute to complain and 25% of the time I’ve known you, you’ve been full of negativity. It’s not a good look.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WaxdhKvNnlaJNgj_Lo-n6w.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/BbQLHCpVUqA?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Alejandro Escamilla</a> on <a href="https://unsplash.com/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>I can’t imagine a situation where complaining about your job makes you look good. If you feel it’s that relevant, fantastic. Tell me about it later in a full interview. But don’t spend precious time convincing me that you’re a victim.</p><p>If I’m a candidate, I’m avoiding all opinions about my current employer, good or bad. It’s irrelevant at this stage. If I’ve only got four minutes to convince someone I’m worthy, I’m focusing on personality and skill set. That’s it.</p><h3>Be Interested</h3><p>One of the most surprising things from the night was the number of developers that didn’t want a job. They spent most of the conversation explaining why they were content. They wanted to see what was out there.</p><p>Unfortunately, most of these people chose to mention this at the very end of the conversation.</p><p>To me, this was a waste of both our times. It’s the equivalent of attending an actual speed dating event and ending the conversation with “I’m happily married, I just came for the free beer”.</p><blockquote>“What are you going to do with my information?”</blockquote><p>Uh, maybe contact you so I can hire you? I left so many of the conversations utterly confused. If you’re here to hang out, fine. But be upfront about it.</p><p>If I were attending as a dev who had no intention of joining another company… well, I wouldn’t be attending. But if I had to I’d be sure to lead off the conversation with that. Let the interviewer of the hook. We can take a break and chat. But I would not lead the interviewer on.</p><h3>Leave a Lasting… Something</h3><p>HackerX provides interviewers with names and contact info for each attendee. This sounds good in theory. But after speaking with tens and tens of candidates, it’s not easy to stand out.</p><p>The fast-paced nature of the event means there is zero time for reflection. No time to write more than a word or two about each candidate and a quick little ranking. I marked a few developers with scores of 9’s and 10’s, but by the next day, I had no idea why.</p><p>Just like in real speed dating, you have to do something to stand out and be memorable. A small number of candidates brought resumes. I was able to compare these resumes to my ratings. I gave one dev a 7 in the interview but reached out to him because of his resume.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*ntYkVj-x7E7wS2oLkUz2Qw.png" /><figcaption>Something Like This. Template by <a href="http://www.freepik.com/free-vector/programmer-resume-template_840427.htm">Freepik</a></figcaption></figure><p>If I were to attend as a dev, I would be sure to bring something memorable for the interviewers to take with them. It wouldn’t be a traditional resume though. This is a pretty informal event. Indeed, the resumes seemed a little out of place.</p><p>I would bring a fun overview of my skills and experience with a small profile picture. I would make it smaller and less wordy than my traditional resume. I’d add some color. This way they have something to remember me by. In my experience, it would have put candidates on another level.</p><h3>Try It Out-If You’re Looking</h3><p>If you’re looking for a job or interested in switching I’d still recommend giving it a try. See if there is a <a href="http://www.hackerx.org/">city near you</a> and request an invite. Worst case scenario, it will be a valuable new experience. Best case you may meet your dream job. Just don’t show up if you’re already happily married!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75806fa15875" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/speed-dating-developers-75806fa15875">Speed Dating Your Way to a Better Tech Job</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developers, Apple’s Lousy Beta Will Make You Better]]></title>
            <link>https://medium.com/hackernoon/why-developers-should-download-apples-awful-ios-11-beta-7b1ddc6fc958?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b1ddc6fc958</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[app-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Mon, 07 Aug 2017 14:49:45 GMT</pubDate>
            <atom:updated>2017-08-08T13:40:01.810Z</atom:updated>
            <content:encoded><![CDATA[<h4>What We Can Learn from Apple’s “Mistakes”</h4><p>My month with the beta has been full of problems. Apps crash regularly. The phone restarts a few times a day. Some apps don’t work. Shortcuts I came to know and love are completely gone. Even app switching is borderline unusable. Notifications — my biggest iOS gripe — got even worse.</p><p>But I love it. Here’s why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zdtIG5HE9X535G9t48vkew.jpeg" /></figure><p><em>Most articles out there will warn you to avoid iOS betas on your primary device. There are horror stories of bricked phones and hours spent reverting versions. I’ll echo those warnings. But if you are a software developer at any level, I suggest you take the plunge.</em></p><h3>Learning from Apple</h3><p>Releasing an entire operating system is one of the largest scale betas you can do. If you take a look at the original beta <a href="https://en.wikipedia.org/wiki/IOS_version_history#iOS_11">release notes</a>, there were well over 100 changes made. And there have been many since.</p><p>It may not be very comparable to releasing a new feature in a small mobile or web app. Nonetheless, the large scale can teach us a lot about our own releases.</p><h4>Big Companies Face the Same Problems</h4><p>I’ve always worked on pretty small teams. I recently <a href="https://hackernoon.com/lessons-from-an-experienced-devs-first-solo-app-521bae1411f">wrote a post </a>about my experience creating my first solo app. Many developers don’t know what it’s like to develop at big companies like Google, Facebook or Apple. But most of those developers I’ve talked to subscribe to a common myth.</p><p>Many believe that all those extra developers make for an easier job. That there are fewer problems. Everyone is just building new features and playing tennis. (Because they graduated from the ping-pong tables at their startups).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*NsSLvocTEbG15UTboDM-kA.png" /></figure><p>I’ve recently been reading the <a href="https://www.amazon.com/dp/B01M9ASFQ3/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">DevOps Handbook</a>. There are some great lessons to learn there. But the most valuable one I am getting was not the author’s intention. The case studies in the book make one thing very clear. Larger companies face the same problems my small teams do. Sometimes at even greater magnitudes!</p><blockquote>“I worked on that project for weeks and finally got around to asking a subject matter expert to review my code. It was nearly three thousand lines of code, which took the reviewer days of work to go through. He told me, ‘Please don’t do that to me again.’”</blockquote><blockquote><em>- 2010 Case Study at Google from </em>DevOps Handbook</blockquote><p>Spending a couple hours on a code review doesn’t sound so bad anymore! In the same way, the host of issues on my iPhone has helped me to realize something. The betas I’ve always helped release were fairly similar in stability. Much smaller size, but much smaller teams as well. I may have blamed the bugs on a lack of people, but that wasn’t the real issue.</p><p>Next time you’re discouraged by a lack of people, remember that throwing more people at a problem doesn’t fix it. It brings on more work. Apple doesn’t share their head count. But LinkedIn estimates over 550 software developers currently work there. They’re breaking stuff too.</p><p>I’m on the <em>fourth </em>iOS beta release. There are core functionalities still broken. I love getting a new release to see what the team has been working on. And more importantly, what they haven’t been.</p><h4>Feedback Trumps All</h4><p>So why did Apple release such a lousy beta? Was it released too early and now they’re scrambling? Absolutely not. Apple has a history of releasing betas that brick phones and are borderline unusable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*BYz34qI1MV4I-vJZpn_ovw.png" /><figcaption>iOS Feedback</figcaption></figure><p>No doubt they released it because they know how important customer feedback is. The official iOS 11 release date won’t be until September. There are still a couple months to go. Which gives them plenty of time to gather feedback on new features.</p><p>The original beta removed the ability to easily clear notifications. I hated it. Many others did as well. The fourth beta brought it back and even better than before. Can you imagine the outrage if Apple released something to <em>all</em> iPhone owners that they hated?</p><p>Gathering feedback from a subset of users is crucial. <a href="https://launchdarkly.com/">Launch Darkly</a> is a great tool to help release new features slowly. This avoids hurling new functionality at all of your valuable users to see if it sticks.</p><p>It’s great to see the release notes each time and see how Apple is responding to the feedback they’re receiving. It’s a great lesson for us all as we launch undoubtedly smaller features.</p><h3>ARKit — More than Kitchen Table Games</h3><p>As an extra bonus, the ability to play with ARKit is well worth the price of admission. Especially if <a href="http://www.iphonehacks.com/2017/06/list-iphone-ipad-compatible-arkit-ios-11.html">your device supports</a> it. It’s still worth toying with the code if not but augmented reality isn’t very useful in a simulator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*7jZAjGMY7ZC0esQxn5mceA.jpeg" /><figcaption>ARKit</figcaption></figure><p>The App Store came out way back in July of 2008. This was an unprecedented time for app developers as they got to take advantage of the “app boom.” ARKit is the closest us app developers have gotten to the app boom in quite some time.</p><p>It’s a brand new technology that will immediately be available to millions of people. About <a href="https://uploadvr.com/380-million-iphones-are-arkit-compatible/">380 million devices</a> to be close to exact. If you are a developer of any sorts, you owe it to yourself to download some sample apps. Play around with some demos in XCode. There will never be a better time to develop with this tech.</p><p>Although games are the primary use case for ARKit, don’t count yourself out if games aren’t your thing. Take a look at some of the apps developers have already put together.</p><p>I’ve already used this <a href="https://github.com/DroidsOnRoids/MeasureARKit">tape measure app</a> doing some house projects and its accuracy blew me away. Placing <a href="https://www.youtube.com/watch?v=DSYeN624ick">furniture</a> in the real world is quite practical. And there’s even this GPS app for those that somehow found GPS’s too confusing:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XiiUk6SKhDblbDr44KtogQ.jpeg" /><figcaption><a href="https://9to5mac.com/2017/07/21/arkit-augmented-reality-navigation/">Maps POI Demo</a></figcaption></figure><p>There’s a ton of potential here and it’s worth checking out.</p><h3>Download Now</h3><p>If you need your phone to be perfect all day I’d still hold off. But if you’re a developer with a recent iOS device it’s well worth the headache. It may just make you a better dev. If you’ve <a href="https://beta.apple.com/sp/betaprogram/">signed up for the beta</a>, let me know your thoughts in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b1ddc6fc958" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/why-developers-should-download-apples-awful-ios-11-beta-7b1ddc6fc958">Developers, Apple’s Lousy Beta Will Make You Better</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lessons from an Experienced Dev’s First Solo App]]></title>
            <link>https://medium.com/hackernoon/lessons-from-an-experienced-devs-first-solo-app-521bae1411f?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/521bae1411f</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[app-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Mon, 31 Jul 2017 13:25:34 GMT</pubDate>
            <atom:updated>2017-08-04T12:35:29.130Z</atom:updated>
            <content:encoded><![CDATA[<h4>Tips for Launching a Side Project</h4><p>I have wanted to engage in side projects for a long time. I’ve created or helped create many successful web and mobile applications in my career. I love to build and create. As I take on more of a lead role at work, though, my time writing code has decreased.</p><p>So earlier this year I set out to create my first solo mobile application. The main goal was to go through the entire development and deployment process. I wanted an easy to build app to get my feet wet. Nothing Editor’s Choice worthy.</p><p>I am passionate about productivity. After switching from Android to iPhone, I knew that Apple’s Reminders app was actually close to what I needed. The only problem is how difficult it is to add a reminder. Adding reminders using Siri has date parsing, but the iOS app doesn’t. Siri and I aren’t exactly on speaking terms most of the time. So I created <a href="https://itunes.apple.com/us/app/natural-reminders/id1227097884?mt=8">Natural Reminders</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DRilw9GQ9ij559esFsi6Bg.jpeg" /><figcaption>Natural Reminders</figcaption></figure><p>I’ve since cancelled my Todoist membership and the app has become a part of my daily workflow. I launched it on the App Store for $0.99 and it has been downloaded a whopping… 5 times. And I know all 5 people. This was not a failure though. Here are some of the things I’ve learned during the process.</p><h3>Create an MVP</h3><p>It’s important to have some sort of a gauge in the interest level of the product you’re creating. If you don’t believe in it, you may as well stop right now. I knew that I wanted Natural Reminders. That was enough to get started and to keep me going.</p><p>But I spent too much time perfecting little things. Too much time adding extra functionality that I didn’t need. I could have launched the app a month sooner. I won’t say that month was a waste of time. But I could have embarked on a new side project, or spent more time getting users.</p><p>Next time, I’ll focus on creating a Minimum Viable Product (MVP). A solid product that may be missing some features. You can always add features. You can always adjust based on customer feedback. You can’t if you have no customers. Accept your losses and move on.</p><h3>Free is Key</h3><p>I didn’t spend much time considering pricing. I figured I’d put ads in and call it good. After some research, and knowing how much I don’t like ads, I decided against it. Productivity apps typically cost money, so I priced it at $0.99 and that was that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*mCF-tb0Yv_R9YLT1rBeHTA.jpeg" /><figcaption><a href="http://sourcebits.com/app-development-design-blog/paid-vs-free-apps-app-store-vs-google-play/">Source</a></figcaption></figure><p>A dollar is not a lot in the App Store. I know people who have spent hundreds of dollars on Pokemon Go alone. But it is a lot for something you know nothing about, from someone you know nothing about.</p><p>A couple of my 5 downloaders even scoffed at the idea of having to spend a dollar on my app. And they were family! How could I expect a stranger to wonder upon it? Productivity apps may usually cost, but you have to have some context.</p><p>Next time, something has to be free. I can only think of a handful of times I purchased something on the store with no context. Only after trying a limited version am I convinced this is something that should be a part of my workflow.</p><h3>Launching a Product Takes Time</h3><p>Last weekend my wife and I went hiking. It was a great time, and we were thrilled to arrive back at the parking lot. Only to realize it was the wrong one. Our car was about 3 miles away. Oops. Normally 3 miles is easy, but we arrived at the parking lot with a mindset that we were finished. That was a rough 3 miles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z5EjB_6TMdfpyj8TfGqo8g.jpeg" /><figcaption>Not Quite Done</figcaption></figure><p>Similarly, I was excited when I called the app production ready. I figured it would be on the store in no time and I’d be ready for my next project. I was ready to move on. I just had to figure out how to launch it. But that is a very time consuming process.</p><p>I am a software developer. One of my main motivations for side projects is the ability to focus on coding. And during development I was able to do that. But then it was time to launch the thing. Now I have to be a marketer. A salesman. There’s a lot that goes into it.</p><p>After some research I figured the easiest way to get the product out there for free would be <a href="https://www.producthunt.com/posts/natural-reminders">Product Hunt</a>. I did everything the “Product Hunt” way. I tracked down someone to hunt out and even beta test the app. I even spent time creating a <a href="http://proefficience.com/natural/">marketing site</a> for it.</p><blockquote>The app launched and got a total of 4 up votes.</blockquote><p>Next time, I’ll plan to spend a lot more time on marketing. I was so ready to move on I didn’t spend enough time on marketing. Granted, I knew this particular app wasn’t worth marketing anyway. But the point was to go through the whole process.</p><h3>Success is What You Make It</h3><p>All this said, it may seem like my first app venture was a failure. I don’t see it that way though. Creators should never see any completed project as a failure. I accomplished my goal of going through the entire development and deployment process.</p><p>Not only that, but I still use the app as a part of my daily workflow. I saved $2.99/month on my Todoist subscription. I also have some great date parsing code that I can use on future work/solo projects. This side project was a success.</p><h3>Next Steps</h3><p>Now that I’m not so eager to move on from this project, there are some things I could still do with it. The best experiment I could do is make it free. I can offer core functionality with an in-app purchase to unlock everything. It’ll be interesting to see if this would add any users.</p><p>More importantly, though, is to continue with my next side project. All programmers should have side projects. The lessons learned are invaluable. They look good on a resume. You might even make something that’s successful. But success of the project is not the goal. Side projects are one of the best ways to improve your value, despite the success of the project itself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=521bae1411f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/lessons-from-an-experienced-devs-first-solo-app-521bae1411f">Lessons from an Experienced Dev’s First Solo App</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[It Works on My Machine]]></title>
            <link>https://medium.com/hackernoon/it-works-on-my-machine-f7a1e3d90c63?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/f7a1e3d90c63</guid>
            <category><![CDATA[it-works-on-my-machine]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Tue, 23 May 2017 14:27:12 GMT</pubDate>
            <atom:updated>2018-12-14T15:19:29.071Z</atom:updated>
            <content:encoded><![CDATA[<h4>Separating junior developers from the experienced</h4><p>When I was a junior developer there was a certain saying people knew me for. I repeated it again and again. It even bothered me that I had to say it so often. I said it when customers encountered bugs. When customer support claimed something I “fixed” was still broken. When new features released with poor feedback.</p><blockquote>It works on my machine!</blockquote><p>When customers faced issues, my default reaction was to blame them. I would never release something to production that I knew didn’t work. I would have noticed something as obvious as that. This is your fault. Go back and try again.</p><p>It took me a long time to recognize that a pattern was forming, though. There were a handful of times where it was user error. But most of the time, the user would come back to me and claim they were still experiencing the problem.</p><blockquote>“It works on my machine. Let’s go see what you’re doing wrong… Oh.”</blockquote><h3>It Doesn’t “Work” if the User Doesn’t Understand</h3><p>When comparing my user’s workflow to mine, I often was able to deduce that their issue wasn’t actually a problem. They were doing something wrong. I would tell them what their problem was, give them instructions, and call the issue resolved.</p><p>This is wrong for many reasons.</p><p>First, you’re telling the user they were wrong. That it’s their fault. No one likes to be wrong. They’ve already had a poor experience using the product, and now they’re told it’s their fault. It takes a lot of patience to stick around after all that, and most users don’t have it.</p><p>Second, if one user had a problem, odds are they are not the only people that think this way. Two issues will come from these users. The problem will keep popping up. So either you or customer support are going to be stuck answering the same question over and over again.</p><p>Others will think the it’s a broken feature, and not say anything about it. These guys are not going to stick around for long. And unlike the complainers, you’ll never know why.</p><p>User experience problems are just as important as bugs. They separate great products from mediocre ones. It doesn’t matter if you agree with how the user got to their error state or not. Our goal as developers is to get the software out of the way of the users’ goals.</p><h3>Process All User Feedback</h3><p>Over the years I have realized how valuable user feedback is. More importantly, I’ve realized we must deal with every piece of user feedback in some way.</p><p>No doubt, some feedback is going to be garbage. They want something no one else wants. By implementing their change it would cause issues for the majority. It’s not worth the time. But we should still document and quantify it somewhere.</p><p>This way we know what our users are saying. More than that, it encourages the user that their feedback is helping improve the product. This is much better than telling them they were wrong. That the developer had no problem getting it to work, and that it’s their fault.</p><p>To be clear, this goes for customers and internal teams such as QA alike. When someone is testing your feature, the last thing they want to hear is how great it works for you. Work with your testers to iron out user experience issues before they get to production. Your customers will thank you.</p><h3>This is a Junior Developer Saying</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ookfwogTLx_1qhHaiFJoJw.png" /><figcaption><a href="https://medium.com/@KJump/it-works-on-my-machine-f7a1e3d90c63">Source</a> From Don’t Hit Save</figcaption></figure><p>As I’ve progressed in my career, I’ve come a long way from the guy whose computer worked so well. It can be difficult to swallow sometimes. But I know that if someone had an issue with something I worked on, I made a mistake. I missed something. I didn’t take a certain use case into account.</p><p>And as I’ve worked with more and more developers, I see that this is not a saying experienced developers use. They realize their users are not liars and have valuable feedback. Junior developers, though, use it frequently.</p><p>Part of the reason junior developers are so apt to disagree with feedback is that they take it personal. Bad feedback is an attack on them, not their product. They get defensive. What do we do when get defensive? We deflect. It’s not my problem, it works fine for me! This is on you. What did you do?</p><p>We all have to realize that feedback, good or bad, is not about you. Feedback is for a feature or product. Us developers are not defined by a bad feature. Nor are we defined by a good one. Developers are defined by how well we solve problems, no matter who it is that is experiencing them.</p><figure><a href="http://bit.ly/HackernoonFB"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hqOaABQ7XGPT-OYNgiUBg.png" /></a></figure><figure><a href="https://goo.gl/k7XYbx"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vgw1jkA6hgnvwzTsfMlnpg.png" /></a></figure><figure><a href="https://goo.gl/4ofytp"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKBpq1ruUi0FVK2UM_I4tQ.png" /></a></figure><blockquote><a href="http://bit.ly/Hackernoon">Hacker Noon</a> is how hackers start their afternoons. We’re a part of the <a href="http://bit.ly/atAMIatAMI">@AMI</a> family. We are now <a href="http://bit.ly/hackernoonsubmission">accepting submissions</a> and happy to <a href="/service/mailto:partners@amipublications.com">discuss advertising &amp; sponsorship</a> opportunities.</blockquote><blockquote>If you enjoyed this story, we recommend reading our <a href="http://bit.ly/hackernoonlatestt">latest tech stories</a> and <a href="https://hackernoon.com/trending">trending tech stories</a>. Until next time, don’t take the realities of the world for granted!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f7a1e3d90c63" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/it-works-on-my-machine-f7a1e3d90c63">It Works on My Machine</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How do you Code when Google Can’t Help?]]></title>
            <link>https://medium.com/@KJ.Jones/how-do-you-code-when-google-cant-help-457df159a326?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/457df159a326</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Tue, 07 Feb 2017 15:13:25 GMT</pubDate>
            <atom:updated>2017-02-07T15:13:25.967Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2jQbFw0Y3E6FCug8r0noFw.png" /></figure><p>I’ve been on the cutting edge of technology my entire programming career. Many years ago I started off in .NET. It may not have quite the same traction today, but it was big back then. Nowadays it’s all about the MEAN stack. No matter the technology, I’ve always worked alongside thousands of other developers.</p><p>This works out well for everyone. As programmers we do a <a href="https://www.reddit.com/r/programming/comments/3bwo68/how_much_does_an_experienced_programmer_use_google/">lot of Googling</a>. It’s often thought that with more experience comes less Google use. In my experience it’s quite the opposite. With more experience comes more slight nuances you don’t need to remember. After all:</p><blockquote>Never memorize something that you can look up.</blockquote><blockquote>-Albert Einstein</blockquote><p>The vast majority of the time, this all works out great. We all learn from each other’s questioning, pondering and answering. Blog posts, Stack Overflow and a variety of other training resources give us a wealth of information at our finger tips. But what do we do when these resources don’t have what we’re looking for?</p><h3>A Barren Wasteland</h3><p>Recently I received a project that required me to write a Windows service. Windows services aren’t built much anymore. It’s all about mobile, web and working cross-platform. A Windows service is quite the opposite of where things are going in technology.</p><p>Nonetheless, there are some rare use cases that only a Windows service can solve. So I set out to build the best Windows service possible in 2017. I knew It wouldn’t have the typical buzzwords that make great applications these days. But it could still be a well-architected, well-written and maintainable piece of software.</p><p>Before setting out on any new project, I make it a habit to do some research on the framework. I learned a lot from <a href="https://medium.com/@KJump/new-frameworks-arent-better-you-are-7b608ee8e807#.r88zomwiu">my research</a> back in the .NET world, and after re-familiarizing myself with .NET, it was time to look into Windows services.</p><p>I’d planned to read a couple articles, and skim through a good book on the subject. I’d review some recent Stack Overflow posts and move on. Windows Services aren’t as new and sexy these days (I don’t know that they ever were), so I knew it would be a different experience than normal. I was still surprised, though, when I found that the information on Windows services out there isn’t just scarce. It’s a ghost town.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DUlDK2a9grWi3P-JkBsj6w.jpeg" /></figure><p>The first Google result for “<a href="https://www.google.com/search?q=windows+services+acrhitecture">Windows Service Architecture</a>” is an article from 2005. The first Stack Overflow post is from 2010. That’s ancient lore in the world of programming.</p><h3>What Do We Do?</h3><p>I knew this was going to be a much different experience than I’ve ever worked with. I’m picking on Windows Services here, but the same principle applies to all outdated technologies. So what do we, as programmers, do when faced with a challenge like this? We have a few different options.</p><h4>Focus on Dates</h4><p>If you’re sticking to Internet sources, be sure to check the dates of the resources. Chances are, you aren’t the first and only person to delve into this older technology recently. You’ll have to do a lot more digging than normal. But it’s well worth it to ensure you have the most up to date information. This way you don’t go down a rabbit trail of outdated information.</p><h4>Check Your Sources</h4><p>Checking sources is something high school taught us. It’s always good advice, but often times Google’s first result is enough. Sources are even more important, though, when dealing with older technology.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*4aR6CAhmKivyR1gQrJGhmQ.png" /></figure><p>As mentioned above, the dates matter, but sources matter more. That article from 2005 is from Microsoft’s TechNet. Does that mean it’s guaranteed to be up to date? No, but I trust an old Microsoft article much more than some random guy’s blog post from 2008.</p><h4>Share Your Findings</h4><p>One of the best things about the programming community is the shared knowledge between programmers. A new blog post on Windows Services is not going to get the traction as a fancy new JavaScript technology. But that doesn’t mean it’s any less valuable.</p><p>There’s also a good chance that by being the lone wolf in the game, you can still get some pretty hefty traffic. Take SyncFusion, who wrote a <a href="https://www.syncfusion.com/resources/techportal/details/ebooks/windowsservices">free book</a> on Windows Services back in 2015. It’s the most up to date resource I found. it isn’t anything groundbreaking, but it brought me to their site and introduced me to their brand.</p><h3>Conclusion</h3><p>I’ve been using Windows Services as an example a lot here, but again, the principle is same everywhere. Windows Services aren’t all that complicated and don’t need a ton of resources. But that’s similar to plenty of other new technologies that do have the benefit of so many resources these days.</p><p>What advice do you have for working on outdated technology (other than not working on it)?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=457df159a326" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Be a Programmer for a Non-Software Company]]></title>
            <link>https://medium.com/hackernoon/how-to-be-a-programmer-for-a-non-software-company-80c499bd9bd5?source=rss-c84dfc3a2036------2</link>
            <guid isPermaLink="false">https://medium.com/p/80c499bd9bd5</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[KJ Jones]]></dc:creator>
            <pubDate>Mon, 23 Jan 2017 18:43:09 GMT</pubDate>
            <atom:updated>2017-07-14T22:09:12.004Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-At6s-mG4S1Ph8g9cmM9Vg.jpeg" /><figcaption>Pick Your Poison</figcaption></figure><p>As programmers, we are faced with a lot of decisions when looking for and ultimately deciding on a job. Pay is important in such a competitive market. One must look at benefits and vacation. The work environment is also very important, especially since the software industry is full of fun and exciting work environments unlike any other field.</p><p>Once a company seems right, we then have to make sure we meet the often very strict qualifications. Are we familiar with the technology? Is the company engaging in relevant best practices? This is no easy easy task and it can take weeks of planning and research to find out which companies would be a good fit.</p><p>Once a position is of interest, we then have to do one of the most important and age old practices of researching the company itself. This is good advice for applying at any company, of course, but there is an additional question software developers must ask themselves: is this a software company, or company that happens to write software?</p><p>This concept certainly isn’t mentioned much in the school systems, and it is something that both junior and senior developers alike need to ask. Software companies like Google and and Facebook are 100% invested in software and the developers that create it. This is not always the case with companies that find their profit from other products than the software itself and programmers need to be very careful in these situations.</p><h3>What’s the Difference?</h3><p>There are a number of advantages to working for a software company. The most obvious is simply that everyone involved either understands software or will not last long if they don’t. Everyone speaks software and understands the challenges and realities that come with creating it.</p><p>Way back in 2007, Joel Spolsky gave a <a href="https://www.joelonsoftware.com/2007/12/04/talk-at-yale-part-2-of-3/">talk</a> about this very subject. He was talking more about developing internal tools, but the same principles apply to creating software that is just a means to some other end as well. He states that one of the biggest gripes is:</p><blockquote>You never get to do things the right way. You always have to do things the expedient way.</blockquote><p>This makes sense because ultimately, it is not the software itself that brings in the most ROI. It’s not as important, then, that you use the best practices out there. Forget TDD, documentation, continuous integration or automated testing. Get it done quickly. Move on. Software companies will rarely sacrifice quality, other companies will.</p><p>Another advantage of working of a software company is the value that is placed on the programmers. Because software is directly related to making money, developers are more valued, and generally have a much brighter future in the company than they would otherwise. Being stuck on these types of teams can be miserable.</p><h3>Embrace the Situation</h3><p>So that’s it, don’t ever work for a non-software company right? Not so fast. There are advantages out there as well, and given the right company and the right team, it can be an even more enjoyable and rewarding experience than being just another team.</p><h4>Be Software Development Advocates</h4><p>One of the key things that can help programming teams working for non-software companies is to be an advocate for software <em>development</em>. These days, you probably won’t need to advocate for software itself. Software is seen as the magic tool that fixes whatever problem the business is facing at the time. The development process, though, is much less clear.</p><p>Spend some time explaining to the business about technical debt. Explain why the best practices exist and what implementing them will do to the project as a whole. You’ll never be able to justify adding two weeks to a project just for the sake of being “proper”. It has to solve a business need and bring in some sort of monetary value.</p><p>When advocating for proper development practices, you’ll need to present the information in a way that the business understands. In a software company, or even internally amongst other developers, you could probably get away with explaining something over coffee, in a quick meeting or a detailed email. For the non-programmer, you’re going to need to do more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*TN6b4yhtfmN4Jz60NfaaHw.jpeg" /><figcaption><a href="http://www.goalcast.com/2015/11/03/4-easy-tricks-to-create-an-epic-presentation/">Source</a></figcaption></figure><p>You might need to pull out those PowerPoint skills you learned back in school. It will depend on the organization, but most have a typical means they have for communication. In my experience, it’s slide shows. Put together a <em>professional</em> slide show. Everyone else in the company pitches their ideas this way, programmers shouldn’t expect to be any different.</p><h4>Encourage, But Limit, Collaboration</h4><p>As I mentioned earlier, software can be seen as that magic solution that solves problems but is often so far removed from the day to day user it scares them. Encourage other people in the company to get involved. Encourage them to submit ideas and provide feedback on the project as it is being developed.</p><p>As software developers, we know how rewarding it is to be able to think of something and then immediately be able to go out and implement it. It’s similarly rewarding to think it and then watch it be implemented. This can really get an organization excited about software development and more importantly, interested in the process, not just the end result.</p><p>All that said, once someone gets a taste of being able to affect the development process, it can be a dangerous thing. By opening up the channels to development, this can let in a flood of well-meaning requests, without an understanding of what that will do to the deadlines. This is why advocating for the process is so important. Everyone must know what “just one quick little feature” will do to the overall project.</p><h4>Communication is Key</h4><p>As always, communication is probably the most important piece when it comes to getting the company fired up about software. A software team will never be valued if they are only seen as an external team that create products and then disappears.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OxUjEfR3pck4mYM38oC5Rw.jpeg" /></figure><p>Keep everyone in the loop. Explain to them delays. Share milestones and achievements. By putting in the effort, you’ll undoubtedly be one of the best communicating software teams they’ve ever worked with, and this has tremendous value.</p><h3>Conclusion</h3><p>Is it better to work for a software company? It truly depends. There are certainly plenty of advantages, and for the programmer looking to coast right on through their career, they should probably stick to software companies. However, for those willing to put in the effort, willing to work on soft skills and take a step out of the IDE a bit, working for a non-software company can be truly rewarding experience.</p><p>If you’re in the process of looking for a new job, think very hard about what kind of products the company sells. If they don’t focus on software, be sure to make this a high priority discussion point during the interview process. If you can’t guarantee that software development will be a priority, run. If you’re currently working for a non-software company, do what you can to prove the value and educate the rest of the business.</p><p>I’ve said it once and I’ll say it again: coding is the easy part. It’s interacting with others that is the challenge. If you’re working for a non-software company, take the challenge and put in the effort and it can make you an even better programmer.</p><figure><a href="http://bit.ly/HackernoonFB"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hqOaABQ7XGPT-OYNgiUBg.png" /></a></figure><figure><a href="https://goo.gl/k7XYbx"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vgw1jkA6hgnvwzTsfMlnpg.png" /></a></figure><figure><a href="https://goo.gl/4ofytp"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKBpq1ruUi0FVK2UM_I4tQ.png" /></a></figure><blockquote><a href="http://bit.ly/Hackernoon">Hacker Noon</a> is how hackers start their afternoons. We’re a part of the <a href="http://bit.ly/atAMIatAMI">@AMI</a> family. We are now <a href="http://bit.ly/hackernoonsubmission">accepting submissions</a> and happy to <a href="/service/mailto:partners@amipublications.com">discuss advertising &amp; sponsorship</a> opportunities.</blockquote><blockquote>If you enjoyed this story, we recommend reading our <a href="http://bit.ly/hackernoonlatestt">latest tech stories</a> and <a href="https://hackernoon.com/trending">trending tech stories</a>. Until next time, don’t take the realities of the world for granted!</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*35tCjoPcvq6LbB3I6Wegqw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80c499bd9bd5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/how-to-be-a-programmer-for-a-non-software-company-80c499bd9bd5">How to Be a Programmer for a Non-Software Company</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>