<?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 Tobias Reiss on Medium]]></title>
        <description><![CDATA[Stories by Tobias Reiss on Medium]]></description>
        <link>https://medium.com/@basecode?source=rss-24fc3307435------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Dem7ndRVkkB-KsDj1HGWhQ.jpeg</url>
            <title>Stories by Tobias Reiss on Medium</title>
            <link>https://medium.com/@basecode?source=rss-24fc3307435------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:16:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@basecode/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[Supporting Large-Scale Digital Signage Deployments]]></title>
            <link>https://medium.com/adobetech/supporting-large-scale-digital-signage-deployments-62319d7d70c7?source=rss-24fc3307435------2</link>
            <guid isPermaLink="false">https://medium.com/p/62319d7d70c7</guid>
            <category><![CDATA[aem]]></category>
            <category><![CDATA[digital-signage]]></category>
            <category><![CDATA[adobe]]></category>
            <category><![CDATA[aem-screens]]></category>
            <category><![CDATA[adobe-experience-cloud]]></category>
            <dc:creator><![CDATA[Tobias Reiss]]></dc:creator>
            <pubDate>Tue, 03 May 2022 17:27:18 GMT</pubDate>
            <atom:updated>2022-05-03T17:29:27.460Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>TLDR</strong></h3><ol><li>We recognised the unique requirements of both omnichannel content management and digital signage management, which adds a layer of hardware device management and communication.</li><li>We found the requirement variances mainly expressing themselves in the areas of read versus write optimisation, scaling with the growing number of players as well as the coupling of general omnichannel content management concerns.</li><li>We developed ways and means to ensure our latest innovation of Experience Manager Screens included resiliency, automation, and scalability inherently in the very architecture of the solution.</li><li>We applied the principles of event streaming and separated read and write operations to enable us to process incoming data at scale, while independently optimising read and write concerns. We enabled elasticity by allowing separate parts of our application to scale independently, down to the function level, reducing dependencies and blast radius.</li></ol><h3><strong>From ten thousand to a hundred thousand of devices</strong></h3><p>At its inception, AEM Screens was embedded as an add-on in AEM. With that, we benefited from an optimised delivery strategy and support for thousands of digital signage devices right from the beginning. A few years later, we set the ambitious goal to improve our overall system to scale from ten thousand to a hundred thousand of digital signage devices. The journey to the cloud resulted in exactly the architecture needed to satisfy our goal while reducing operational costs for our customers. Screens as a Cloud Service delivers on three functionality requirements for large-scale digital signage:</p><figure><img alt="Digital signage management focuses Player directional communication, zero-config operations and scaling of number of Players." src="https://cdn-images-1.medium.com/max/748/1*cTZEEq_RH9r2XwjWyBLgDg.png" /></figure><h3><strong>Architecture</strong></h3><p>Screens as a Cloud Service includes three main components:</p><ul><li><strong>Content Provider</strong>, which is the Screens add-on running on Cloud Service or Adobe Managed Services (AMS), allows content authors to create and manage channels. They can add new content and edit it without worrying about the details of creating displays or player registration.</li><li><strong>Services Provider</strong>, which is the digital signage management service running on the Adobe I/O Runtime, allows content authors, developers, and administrators to manage displays and players for content playback once the content is added to the channels. Additionally, Screens Services Provider informs the Player Application about where and when content is going to play at a high level.</li><li><strong>Player Application (Player)</strong>, which is the application that runs on the digital signage device, plays the content and maintains a connection to Services Provider to send IoT events and receive and process commands.</li></ul><figure><img alt="AEM Screens as a Cloud Service simplified architecture." src="https://cdn-images-1.medium.com/max/1024/1*fQWFahDzqZ9qF4c08y5e9w.png" /></figure><p>The following sections elaborate on how the architecture supports large-scale digital signage deployments, taking an in-depth look at the arrows flagged as <strong>A</strong> and <strong>B</strong>.</p><h3>Separating Content Provider and Services Provider does the trick!</h3><p>Two of the three components of Experience Manager Screens, namely Services Provider and Player, represent concepts that are entirely outside what one would consider content management. Separating content management from digital signage management is the logical consequence.</p><p>Some examples of benefits of the separation include:</p><ul><li>Content management for web, mobile, and other channels is often predicated on unidirectional content delivery <strong>(A)</strong>. This means that content authors create, edit, and stage content on an authoring instance, then publish the content to one or more publish instances. There is almost never a reverse flow of data from the publish to the authoring instances. Digital signage management, however, relies on bidirectional communication <strong>(B) </strong>with its player applications, heavily slanted toward receiving data from the player as telemetry. In digital signage management, we need to see the player status, for example, is it online or offline? What were its last actions? Did it execute a command sent, download its content, and if so, how often?</li><li>Digital signage management is basically a zero-configuration business. Players of any customer are always treated the same and go through the same player lifecycles, requiring no customer-specific configuration.</li><li>Separated services allow automatic and elastic scalability, depending on the delivery strategy, which reduces the overall operational costs for the customer.</li></ul><p>Content Provider is designed to deliver content, fast and primarily in one direction, to the Player Application <strong>(A)</strong>, while Services Provider is designed to communicate bidirectionally, where millions of digital signage devices and smart TVs report their status every few minutes or even seconds <strong>(B)</strong>. This separation of providers allows different communication techniques and methods to be chosen to make each system resilient and performant based on use cases.</p><h3>Content Provider (AEM as a Cloud Service or Adobe Managed Services)</h3><p>Screens Content Provider is optimised for fast read access so that Player can download images, videos, and other content reliably without putting the system under stress. This is possible because the requests initiated by Player to Content Provider are aggressively cached in four layers:</p><ol><li>Local cache of the Player Application</li><li>Content delivery network (CDN)</li><li>Experience Manager Dispatcher</li><li>Experience Manager Publish</li></ol><p>Once the content resource is requested, it goes through the caching layers from Local cache to the original source on an Experience Manager publish instance, where Local cache is the most efficient cache available in Player itself. During redeployments of the publish service, the Dispatcher cache is cleared and subsequently warmed up before the new publish nodes accept traffic.</p><h3>Services Provider</h3><p>Screens Services Provider leverages Adobe’s own serverless platform, the Adobe I/O Runtime, for optimising write-heavy data flows. It is event-based and composed of loosely coupled functions as a service, allowing for automated elastic scaling in multiple regions and increased resiliency, where failure of a particular service doesn’t take down the whole system.</p><p>The public API, exposed by Adobe services, is protected from certain threats, like malicious users or spikes in traffic, leveraging the Adobe I/O API Gateway. It balances the requests and allocates new resources, depending on the operational use case and region.</p><p>The persistent layer relies on Apache Kafka, an industry-wide, battle-tested event streaming engine that facilitates an asynchronous producer/consumer pattern. This pattern<br>enables an event-based architecture, which allows the separation of read and write specific operations (CQRS) focusing on high throughput, accepting higher latency.</p><figure><img alt="The Services Provider’s key priorities are fast read/write operations, scaling and decoupling of services." src="https://cdn-images-1.medium.com/max/822/1*eo3P_aN78_gQPLZ5hxOaUQ.png" /></figure><h3>Deploying, managing and upgrading large deployments of Player Applications</h3><p>One of the largest costs in a large-scale digital signage deployment is deploying, managing, and upgrading thousands or millions of Player Applications. Suddenly the workflows that worked for a few dozen are no longer going to work. AEM Screens has carefully designed large-scale workflows for these operations to drive cost savings for customers. AEM Screens highly recommends that customers use operating system-specific commercial device management solutions for managing large deployments.</p><h4><strong>Player Applications large scale deployment features</strong></h4><ul><li>Automatic updates</li><li>Remote provisioning</li><li>Bulk registration</li><li>Bulk content assignment and playback</li><li>Default schedules for content</li><li>Player-friendly name</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62319d7d70c7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adobetech/supporting-large-scale-digital-signage-deployments-62319d7d70c7">Supporting Large-Scale Digital Signage Deployments</a> was originally published in <a href="https://medium.com/adobetech">Adobe Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test public API, not implementation details]]></title>
            <link>https://medium.com/@basecode/test-public-api-not-implementation-details-3d563af5f71?source=rss-24fc3307435------2</link>
            <guid isPermaLink="false">https://medium.com/p/3d563af5f71</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Tobias Reiss]]></dc:creator>
            <pubDate>Tue, 08 Dec 2015 22:20:00 GMT</pubDate>
            <atom:updated>2015-12-08T22:32:54.938Z</atom:updated>
            <content:encoded><![CDATA[<p>There are good reasons why programmers perform tests themselves in contrast to letting an external testing department (QA) perform the tests. The programmer is able to discover errors in code and in general design decisions much faster and can react immediately, as one might say, the feedback loop is very short. On the other hand, when programmers have both, the test and the implementation in mind, they’re tempted to test code that an external wouldn’t test, simply because the external only know about the spec but not the implementation. That way I once wrote way more tests than needed and at the time of writing the tests felt confident with that approach because more tests are better than less tests and JavaScripts lacking of private members literally encouraged me to do this anyway. Well, I paid the price some weeks later, when a minor change took me way to long to implement because of some dozens of failing tests that shouldn’t be affected by my change. But what exactly is bad about testing other things than public API?</p><p>Consider the following little code snippet:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/11d17ac8ed21f5df34287a233807c78e/href">https://medium.com/media/11d17ac8ed21f5df34287a233807c78e/href</a></iframe><h3>What is public API?</h3><p>First of all, make yourself aware of what methods of your Auth class are meant to be accessible and visible to the user of the class. That’s the public API. In this case the only method that is supposed to be visible is:</p><blockquote><em>boolean</em> function <strong>login</strong>(<strong>username</strong><em>:String</em>, <strong>password</strong><em>:String</em>)</blockquote><h3>What are implementation details?</h3><p>Now that you have settled the public API, everything else can be considered as implementation detail, including the _isEmpty method. I use a single underscore prefix to make the distinction more visible. But that’s only a coding convention and not a JavaScript feature and therefore doesn’t prevent a tester from using it per se. It can help code-reviewers with detecting private members though.</p><p><strong><em>Tip:</em></strong><em> A user of your class Auth only cares about public API because that’s the only API that is well documented and maintained. So let’s make sure that this API works as expected and only test login. Applying this approach keeps the amount of tests as small as possible but effective as necessary.</em></p><h3>A bad test</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/125131a8f66a8029a4134498245a6cdc/href">https://medium.com/media/125131a8f66a8029a4134498245a6cdc/href</a></iframe><p><strong><em>Testing Terminology:</em></strong><em> A test that fails, although the code changes shouldn’t have affected the test are often called: Fragile Test</em></p><h3>Good tests</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd617de076f266b1a7ff6e3d7b629b36/href">https://medium.com/media/dd617de076f266b1a7ff6e3d7b629b36/href</a></iframe><p>Focus on simplicity, correctness and shortness of tests. You and your co-workers will enjoy the readability. Internal documentation meant for developers can be replaced by your tests. From now on your tests are the spec. What about refactoring? Super easy. Let’s say you replace _isEmpty for internal reasons by underscrore.isEmpty() and some days later by lodash.isEmpty(). No problem, you don’t even need to touch the tests. Just execute them and give yourself the confidence that login still works as expected. This process doesn’t only make refactoring easy, it encourages you to make your code continually better and let you react fast on internal design decisions. Code-reviews of refactoring steps can happen faster because one thing is sure, whatever your code does, it doesn’t break the public API because you didn’t touch the tests.</p><h3>Summary</h3><p>KISS! Testing less but the right things improves your development process and makes you and your co-workers happy. Implementation details are never mentioned within the spec, so they never appear within your tests.</p><p><strong>Testing implementation details</strong></p><ul><li>makes refactoring hard</li><li>increases the cost of test maintenance</li><li>does not improve the API</li><li>slows down development process</li><li>a waste of time</li></ul><p><strong>Testing public API</strong></p><ul><li>improves readability of tests</li><li>your tests are the specification</li><li>less but better tests</li><li>refactor fast without touching tests</li><li>faster code review</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3d563af5f71" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>