<?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 Evgeny Fedorov on Medium]]></title>
        <description><![CDATA[Stories by Evgeny Fedorov on Medium]]></description>
        <link>https://medium.com/@evgeny.fedorov?source=rss-5d7fbc92c095------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*8BhCmFHQxAShp__e.jpg</url>
            <title>Stories by Evgeny Fedorov on Medium</title>
            <link>https://medium.com/@evgeny.fedorov?source=rss-5d7fbc92c095------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 15:47:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@evgeny.fedorov/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[Customer Service at ViCueSoft: Hardware assisted (Intel® Media SDK) video pipeline.]]></title>
            <link>https://medium.com/vicuesoft-techblog/customer-service-at-vicuesoft-hardware-assisted-intel-media-sdk-video-pipeline-e2f3bedd210c?source=rss-5d7fbc92c095------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2f3bedd210c</guid>
            <category><![CDATA[media-sdk]]></category>
            <category><![CDATA[vtune]]></category>
            <category><![CDATA[hevc]]></category>
            <category><![CDATA[video-compression]]></category>
            <category><![CDATA[codec]]></category>
            <dc:creator><![CDATA[Evgeny Fedorov]]></dc:creator>
            <pubDate>Thu, 22 Oct 2020 14:28:15 GMT</pubDate>
            <atom:updated>2020-11-21T07:03:31.644Z</atom:updated>
            <content:encoded><![CDATA[<p>Hi,</p><p>My name is Evgeny. I am a Consulting Services Manager at ViCueSoft. In my role, I regularly assist customers with their video compression tasks and work tirelessly to ensure that they receive the ace user experience they deserve. Here, I’d like to demonstrate one of the user cases that we solved.</p><p><strong>Introduction:</strong></p><p>Live streaming using mobile devices such as smartphones is the norm in today’s world. Such transmission method may seem routine to an average smartphone user, but the underlying engineering challenges are complex. The volume of traffic is enormous and users demand speed and precision. Given the constraints of network bandwidth (4G/5G/WiFi) and reliability, a key engineering challenge is to transform the nature of the video data and deliver best possible user experience.</p><p>The following example would perhaps illustrate the challenges associated with network bandwidth inconsistencies. Suppose, you are streaming a live feed while travelling on a suburban train and suddenly you hit a tunnel. In an instant, the signal strength drops and the software would need to react rapidly in order to ensure uninterrupted transmission without minimal impact on stream’s visual quality.</p><p>Paraphrasing the abovementioned use case as a technical task we get the following input data:</p><ul><li>Pipeline: 1080i@60fps live encoding and streaming — 16ms for one field.</li><li>Encoder: Intel Gen graphics.</li><li>Linux Media stack: Intel Media SDK, libVA, iHD UMD, libDRM, i915 KMD.</li><li>Problem: Live broadcasting over a fluctuating network and slow encoder adaptation to the changing network conditions.</li></ul><p><strong>For better understanding of our approach let me briefly introduce the video compression basics here.</strong></p><p>Intuitively, video is a sequence of static pictures which follow each other over time. When we are talking ‘video compression’, our aim is to reduce the size of video data to the target size all the while not unduly compromising visual quality.</p><p>Why do we need video compression after all? The principal reason is that uncompressed video occupies enormous network space. For example, a 90-minute 1080p video at 24 fps would need around 750 Gb of storage space. There is no network which could handle such amount of data. To handle such a technical challenge, various techniques and algorithms are developed.</p><p>To allow interoperability among various devices those techniques are standardized in the form of codec standard: AVC/H.264, HEVC/H.265, AV1 and so on. However, these standards only describe syntax and semantics of the compressed video bitstreams. The production of standard-compliance bitstream is entirely up to the video encoder developer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*Z8GKYnTrfL5Pqf2GBltDjA.jpeg" /></figure><p><strong>What are the common blocks of video encoders?</strong></p><p>From variety of techniques there are two modules in focus: Rate-control and Mode-Decision.</p><ul><li>Rate control ensures that the size of compressed bitstream is under bandwidth/size constraints. E.g. we could burn a produced bitstream on a standard CD-ROM.</li><li>Mode-decision chooses the best compression technique for every temporal and spatial part of the current video sequence. It’s a complex optimization problem where the developer is at liberty to invent his/her own techniques and heuristics. The alternative brute force approach is extremely resource and time intensive.</li></ul><p>Let’s review the following image. We have an encoder, which has four compression techniques denoted by<strong> Ti</strong>s, i = 1..4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*LbQNZxrcrSPG3g65g4EUbA.jpeg" /></figure><p>Note that <strong>Rtarget</strong> is the constraint on the output stream size. Thus, in our example Mode-decision module should choose mode <strong>T3</strong>. Modes <strong>T1</strong> and <strong>T2</strong> provide worse quality and <strong>T4</strong> doesn’t satisfy size restrictions. The encoder would need to decide on these modes quickly as there are more frames to encode.</p><p>Following the decisions we would need to generate output bitstream. It is a fairly straightforward and somewhat mundane task.</p><p>As we are using hardware-based encoder let’s review how it is implemented.</p><p>In our case we use Intel® chip with Skylake® microarchitecture and Gen9 GT2 graphics subsystem. Following is a scheme from the official manual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/588/1*sxCPgoSs-NpRM0uPbqVG2w.png" /><figcaption>Gen9 GT2 architecture</figcaption></figure><p>We can split the whole system into two blocks:</p><ul><li><strong>Slice</strong> — a set of programmable shader units for General-purpose computing on graphics processing units (GP GPU).</li><li><strong>Unslice</strong> — a set of fixed function pipelines for media operations, which includes MFX blocks that provide video compression capabilities.</li></ul><p>Now let’s combine our theoretical knowledge and hardware in order to construct a two steps video encoding architecture.</p><ol><li>First step is to implement mode decision and deliver rate control optimization tasks. We implement this on shader units.</li><li>The second step is to create the final bitstream based on the decisions from the first step. This step is performed on dedicated hardware MFX blocks.</li></ol><p><strong>Pipeline optimization.</strong></p><p>It was a long journey but in short here is what we have done:</p><ol><li>new rate control with better handling of network fluctuations,</li><li>new shader kernel to facilitate better decision making by the general mode decision module,</li><li>some minor optimization of the standard media stack.</li></ol><p>As a consequence, this gives up to 30% performance quality improvement. In other words, a previously encoded 6Mbps bitstream could be now delivered at 4Mbps bandwidth with the same visual quality.</p><p>To trace these improvements, we used the effective VQ Probe tool developed by the ViCueSoft team. VQ Probe is a visual instrument for objective and subjective video quality probation. As a tool, it provides a visual quality comparison between two videos using a split-line and various zoom options. Among its multiple exciting functions, there is plotting of RD Curves, calculating BD Rates and evaluating improvements of the video file.</p><p>Figure 1 displays a screenshot from the VQ Probe tool demonstrating rd-curves and it also measures the bd-rate for the original and the transformed videos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*NcH2HyD1ey3ulBnWAxdfiw.png" /><figcaption>Figure 1. Screenshot of rd-curve from VQ Probe.</figcaption></figure><p>Time to celebrate? Not yet, as we encountered new challenges in the form of performance decline and complexity increase. This is due to limitation of the original architecture.</p><p>And our best friend here to spot the root cause of the problems and understand underling hardware work is the Intel® VTune analyzer.</p><p><strong>Let’s configure VTune to run graphics usage analysis.</strong></p><p>After installation we created three scripts:</p><blockquote>1. VTune analysis configuration script for graphics profiling entitled <strong>run_vtune.sh</strong></blockquote><pre><em>#!/bin/sh</em></pre><pre><em>usage () {<br>  echo “Usage: $0 &lt;result_dir_name&gt; [&lt;options&gt;] — &lt;target_app&gt; [&lt;target_app_params&gt;]”<br>}</em></pre><pre><em>if [ -z “$VTUNE_AMPLIFIER_XE_2018_DIR” ]<br>then<br>echo “Error: Environment variable VTUNE_AMPLIFIER_XE_2018_DIR is not defined. Source amplxe-vars.sh file from VTune directory.”<br>exit 1<br>fi</em></pre><pre><em>TARGET_APP=`echo $@ | sed -ne ‘s/^.* — \(.*\)$/\1/p’`</em></pre><pre><em>if [ -z “$TARGET_APP” ]<br>then<br>  usage<br>  exit 1<br>fi</em></pre><pre><em>RESULTS_NAME=$1</em></pre><pre><em>if [ -z “$RESULTS_NAME” ] || [ “$RESULTS_NAME” == “ — “ ]<br>then<br>  RESULT_OPTIONS=”” #save results to the current folder<br>else<br>  RESULT_OPTIONS=”-r $RESULTS_NAME”<br>fi</em></pre><pre><em>OPTIONS=`echo $@ | sed -ne ‘s/^\(.*\) — .*$/\1/p’ | awk ‘{first = $1; $1 = “”; print $0;}’`</em></pre><pre><em>if [ -z “$OPTIONS” ]<br>then</em></pre><pre><em>OPTIONS=” \<br>-collect-with runsa \<br>-knob enable-user-tasks=true \<br>-knob enable-gpu-usage=true \<br>-knob enable-gpu-runtimes=true \<br>-knob event-config=CPU_CLK_UNHALTED.REF_TSC:sa=3100000,CPU_CLK_UNHALTED.THREAD:sa=3100000,INST_RETIRED.ANY:sa=3100000 \<br>-knob gpu-counters-mode=overview \<br>-knob gpu-sampling-interval=0.1&quot;</em></pre><pre><em>fi</em></pre><pre><em>echo<br>echo “run:”<br>echo “$VTUNE_AMPLIFIER_XE_2018_DIR/bin64/amplxe-cl $RESULT_OPTIONS $OPTIONS — $TARGET_APP”<br>echo<br>$VTUNE_AMPLIFIER_XE_2018_DIR/bin64/amplxe-cl $RESULT_OPTIONS $OPTIONS — $TARGET_APP</em></pre><blockquote>2. Script for the application to be profiled. Here we use standard Intel® Media SDK sample. We assume the current directory is media sdk build output. Name it <strong>run.sh</strong></blockquote><pre><em>#!/bin/sh<br>export LD_LIBRARY_PATH=`pwd`<br>export LIBVA_DRIVERS_PATH=/opt/intel/mediasdk/lib64<br>export LIBVA_DRIVER_NAME=iHD<br>./sample_encode h264 -i input.yuv -w 1920 -h 1080 -o stream.avc<br></em></pre><blockquote>3. Main script to gather profiling data:</blockquote><pre><em>#!/bin/sh<br>VTUNE_AMPLIFIER_XE_2018_DIR=/opt/intel/vtune_amplifier ./run_vtune.sh vtune -- ./run.sh</em></pre><p>If everything is ok, we will get a report under newly created ‘vtune’ folder.</p><p>Let’s analyze one of the reports:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*VwrG-pqM08DD43t3YW8DGg.jpeg" /></figure><p>It shows hardware usage pipeline on time scale, where yellow is shader units blocks, and blue — mfx hardware blocks.</p><p>Blank (white)– hardware is idle.</p><p>The top most blue/yellow rectangle — actual task execution; blocks below the top one — queue waiting for execution or result. E.g. under point “3”: one task on shader unit is executed, one wait for its completion and the next task is in the queue; MFX block is idle.</p><p>List of the problems:</p><ol><li>Bad EU/MFX pipeline parallelization. They could work simultaneously. While we generate one field, we could execute decisions on the next.</li><li>General idle process. Hardware do nothing which is inefficient.</li><li>Here is our new kernel, which is too slow.</li></ol><p>Using such visually informative profiling results representation and following several trials of “optimization — profile — analyze” loops we finally solve majority of our problems.</p><p>And here is the result following all optimizations (with CPU traces):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*SiWwIiTS8JmcXPqIvwiuLg.jpeg" /></figure><ol><li>EU/MFX pipelines are paralleled.</li><li>Better hardware utilization achieved with much less idle time.</li><li>We split our kernel into two simpler and faster kernels. Together they work faster than the original one.</li></ol><p>As a result:</p><ol><li>Solved performance degradation.</li><li>Advanced original quality.</li><li>Created a room for further quality increase by adding some more complexity.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ovz4jFxo4c-a-fY1FR-QSg.png" /></figure><p>As you can notice from the example above, VTune is a great tool to visualize media pipeline and profile simultaneously CPU and GPU workload. We would certainly recommend it. Hopefully you have found this article useful. Please feel free to get in touch with questions and comments. That’s all for now. Stay connected!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2f3bedd210c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vicuesoft-techblog/customer-service-at-vicuesoft-hardware-assisted-intel-media-sdk-video-pipeline-e2f3bedd210c">Customer Service at ViCueSoft: Hardware assisted (Intel® Media SDK) video pipeline.</a> was originally published in <a href="https://medium.com/vicuesoft-techblog">vicuesoft-techblog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to setup Intel C-for-media development environment. GPGPU programming on Intel GEN graphics.]]></title>
            <link>https://medium.com/vicuesoft-techblog/how-to-setup-intel-c-for-media-development-environment-gpgpu-programming-on-intel-gen-graphics-2454c03f67fd?source=rss-5d7fbc92c095------2</link>
            <guid isPermaLink="false">https://medium.com/p/2454c03f67fd</guid>
            <category><![CDATA[medium]]></category>
            <category><![CDATA[cmc]]></category>
            <category><![CDATA[gpgpu]]></category>
            <dc:creator><![CDATA[Evgeny Fedorov]]></dc:creator>
            <pubDate>Wed, 31 Jul 2019 15:04:32 GMT</pubDate>
            <atom:updated>2020-03-06T15:25:54.313Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to set up Intel C-for-media development environment. GPGPU programming on Intel GEN graphics.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N3JPfM_SXD7Ji8J3" /><figcaption>Photo by <a href="https://unsplash.com/@shemul?utm_source=medium&amp;utm_medium=referral">Shahadat Shemul</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The Intel C-for-Media compiler(CMC) is an open source compiler that implements C-for-Media (CM) programming language. CM is a new GPU kernel programming language for Intel HD Graphics. CMC is available for Linux and Windows systems. This current article is focused on Linux as it’s a main development platform of the author.</p><p>If you are a Windows user installation is pretty easy:</p><ol><li>Get <a href="https://01.org/c-for-media-development-package/downloads">Intel C for Media package</a></li><li>Extract package in desired directory &lt;install_dir&gt;</li><li>Set environment variable INSTALLDIR = &lt;install_dir&gt;</li></ol><p>Linux is where things became interesting as there some inconsistencies between libraries.</p><p>Ok, lets go and run your first GPU kernel program.</p><h3>Step 1. Set the environment</h3><h4>1.1 Hardware</h4><p>Any CPU with intel graphic GEN 9 or higher onboard. Kabylake is used for the current article.</p><h4>2.2 Software</h4><p>It’s pretty flexible. Only fresh compiler is desirable. Here is what I used:</p><ul><li>CentOS 7.6</li><li>CMake 3.12</li><li>GCC 8.2</li><li>git 1.8</li><li>make 3.82</li><li>Python 3.5</li></ul><h3><strong>Step 2. Build and install CMC toolchain</strong></h3><p>To develop GPU kernels using CMC we need the following packages:</p><ul><li><strong>The Intel(R) C-for-Media compiler — </strong>Clang based open source compiler for creating GPU kernels.</li><li><strong>Libva — </strong>an implementation for open-source Video Acceleration API (VA-API), which provides access to graphics hardware acceleration capabilities for video processing.</li><li><strong>Intel(R) Media Driver for VA-API — </strong>user mode driver.</li><li><strong>Intel Graphics Compiler for OpenCL™ — </strong>an LLVM based compiler for OpenCL™.</li></ul><p>Lets proceed through all the steps:</p><p><strong>2.1 Build and install libva</strong><br>There is a simple way to build this component using the cmake build system.</p><pre>git clone <a href="https://github.com/intel/libva.git">https://github.com/intel/libva.git</a> libva<br>cd libva<br>./autogen.sh --with-drivers-path=/opt/intel/mediasdk/lib64/ --prefix=/usr --libdir=/usr/lib64<br>make -j8<br>sudo make install<br>cd ..</pre><p><strong>2.2 Build and install Intel(R) Media Driver for VA-API</strong><br>Media driver also can be built using cmake.</p><pre>git clone <a href="https://github.com/intel/media-driver.git">https://github.com/intel/media-driver.git</a> media-driver<br>git clone <a href="https://github.com/intel/gmmlib.git">https://github.com/intel/gmmlib.git</a></pre><pre>mkdir build &amp;&amp; cd build<br>cmake ../media-driver<br>cmake --build  . -j `nproc`</pre><p>After these steps, driver and CM runtime are installed in the system:</p><ul><li>User mode driver: /opt/intel/mediasdk/lib64</li><li>Runtime libraries: /usr/local/lib64</li><li>Runtime headers: /usr/local/include/igfxcmrt</li></ul><p><strong>2.3 Build and install Intel(R) C-for-Media compiler</strong><br> Build compiler where “-i” param specifies output directory. Lets call it &lt;cmc_install_dir&gt;, it will be needed later.</p><pre>git clone <a href="https://github.com/intel/cm-compiler.git">https://github.com/intel/cm-compiler.git</a> cm-compiler<br>cd cm-compiler<br>support/scripts/build.bash -d -c -p /usr/local/bin -i `pwd`/../bin</pre><p>Copy “test” directory which contains examples into &lt;cmc_install_dir&gt;:</p><pre>cp test ../bin -r<br>cd ../bin</pre><p>Edit examples makefile:</p><ul><li>Add path to CMC runtime headers from first step to “INCL” set.</li><li>Update path to runtime library (igfxcmrt.so) in compilation command.</li><li>Change path to compilers headers in HW_CMCFLAGS to &lt;cmc_install_dir&gt;/include.</li><li>Add path to cmc compiler binary.</li></ul><p>This can be achieved using follow command:</p><pre>sed -i &#39;s/-I$(CM_ROOT)\/runtime\/include/-I\/usr\/local\/include\/igfxcmrt\ -I\/usr\/include\/libdrm/&#39; test/open_examples/Makefile.linux<br>sed -i &quot;s@^CMC :=@CMC := `pwd`\/bin\/cmc\ #@&quot; test/open_examples/Makefile.linux<br>sed -i &quot;s@\$(CM_ROOT)/runtime/lib/x64/igfxcmrt64.so@/usr/local/lib64/libigfxcmrt.so@&quot; test/open_examples/Makefile.linux</pre><p><strong>2.4 Build Intel Graphics Compiler for OpenCL™</strong><br>Clone compiler and build it accordance to instructions.</p><pre>git clone <a href="https://github.com/intel/intel-graphics-compiler.git">https://github.com/intel/intel-graphics-compiler.git</a> igc<br>git clone -b release_80 <a href="https://github.com/llvm-mirror/llvm">https://github.com/llvm-mirror/llvm</a> llvm_source<br>git clone -b release_80 <a href="https://github.com/llvm-mirror/clang">https://github.com/llvm-mirror/clang</a> llvm_source/tools/clang<br>git clone -b ocl-open-80 <a href="https://github.com/intel/opencl-clang">https://github.com/intel/opencl-clang</a> llvm_source/projects/opencl-clang<br>git clone -b llvm_release_80 <a href="https://github.com/KhronosGroup/SPIRV-LLVM-Translator">https://github.com/KhronosGroup/SPIRV-LLVM-Translator</a> llvm_source/projects/llvm-spirv<br>git clone <a href="https://github.com/intel/llvm-patches">https://github.com/intel/llvm-patches</a> llvm_patches</pre><pre>mkdir build_igc<br>cd build_igc<br>cmake ../igc/IGC<br>cmake --build . -j `nproc`</pre><p>Only Genx_IR tool is required from this package so just copy it to &lt;cmc_install_dir&gt;/bin</p><pre>cp Release/Tools/GenX_IR ../bin/bin/</pre><h4>2.5 Installation notes</h4><p>There are two ways to load and execute GPU kernel programs: with Just-in-time compilation and without.</p><ul><li>JIT way. In this way <strong>step 2.4</strong> is not needed but you will need jitter library which is provided with CM runtime from github (<a href="https://github.com/intel/cmrt.git">https://github.com/intel/cmrt.git</a>).<br> <strong>NOTE:</strong> library provided as binary file built by gcc-4.8.2, so if you want to use it you should build all environment and your code by this compiler.</li><li>“Nojitter” way. In this case you don’t need jitter library, but you should specify target architecture and add “nojitter” string as last argument to LoadProgram call in example code.</li></ul><p>I prefer the nojitter way, and this article will only focus on that method.</p><h3>Step 3. Run samples</h3><h4>3.1 Modify samples to work in “nojitter” mode</h4><p>Edit example smakefile from <strong>step 2.3</strong>.</p><p>Create variableGEN_MODE and set it to target platform. I setKBL as using KabyLake based graphics.</p><ol><li>Add following flags to HW_CMCFLAGS to specify target platform:</li></ol><ul><li>-Qxcm_jit_target=$(GEN_MODE)</li><li>-Qxcm_vme_arch=$(GEN_MODE)</li></ul><p>2. Add some other useful flags:</p><ul><li>-Qxcm ( not necessary, it enabled by default as described by intel, but I recommend adding it)</li><li>-Qxcm_opt_report (errors reporting)</li><li>-Qxcm_print_asm_count (to output count of assembly instructions)</li></ul><p>3. Update paths to CMC and runtime library.</p><p>Example script to do these steps:</p><pre>sed -i &quot;s@-march=\$(GEN_MODE)@-isystem `pwd`/include -Qxcm_jit_target=\$(GEN_MODE) -Qxcm_opt_report -Qxcm_print_asm_count -Qxcm_vme_arch=\$(GEN_MODE) -Qxcm #@&quot; test/open_examples/Makefile.linux</pre><h4>3.1 Build and run sample</h4><p>Now lets run any sample, E.g. histogram_64</p><p>For this change LoadProgram call to “nojitter”, then build and run example:</p><pre>cd ../bin/test/open_examples/histogram_64<br>sed -i &quot;s@program));@ssprogram,\&quot;nojitter\&quot;));@&quot; histogram.cpp<br>make -f ../Makefile.linux<br>./hw_x64.histogram_64</pre><p>That is it! Now you are ready to create your own GPU kernels to run them on Intel graphics. In the next article we will create one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2454c03f67fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vicuesoft-techblog/how-to-setup-intel-c-for-media-development-environment-gpgpu-programming-on-intel-gen-graphics-2454c03f67fd">How to setup Intel C-for-media development environment. GPGPU programming on Intel GEN graphics.</a> was originally published in <a href="https://medium.com/vicuesoft-techblog">vicuesoft-techblog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>