<?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 Charlie Hulcher on Medium]]></title>
        <description><![CDATA[Stories by Charlie Hulcher on Medium]]></description>
        <link>https://medium.com/@chulcher?source=rss-f59083ff4d5d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*K-2ec_llnz9YLmBLHfv_4g.png</url>
            <title>Stories by Charlie Hulcher on Medium</title>
            <link>https://medium.com/@chulcher?source=rss-f59083ff4d5d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 09:19:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chulcher/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[Stop Managing CSS]]></title>
            <link>https://medium.com/@chulcher/stop-managing-css-b9a58ad8b89?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9a58ad8b89</guid>
            <category><![CDATA[css-in-js]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[styled-components]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[http2]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Thu, 31 Aug 2017 23:22:38 GMT</pubDate>
            <atom:updated>2017-09-01T01:12:34.214Z</atom:updated>
            <content:encoded><![CDATA[<p>A response to <a href="https://www.viget.com/articles/managing-css-js-http-2">Managing CSS &amp; JS in a HTTP/2 World</a></p><p><a href="https://www.viget.com/articles/managing-css-js-http-2">This article</a> on getting great performance out of HTTP/2 would have excited me hugely before. Sane structure and tooling around SCSS that allows for the best loading benefits with HTTP/2 is definitely the future when your styles are separate from everything else.</p><p>I believed in separating styles, behavior, and structure for a long time. Problem is, after diving in with Styled Components from the CSS-in-JS movement, I’m not in that camp anymore. We should encapsulate styles, behavior, and structure together.</p><p>With React, we already intermingle behavior and structure to great effect. Is it the indefensibly best way all the time? Of course not, but it’s my favorite for the projects I work on.</p><p>The <a href="https://speakerdeck.com/vjeux/react-css-in-js">CSS-in-JS</a> movement took this to next level: break the last separation. Keep style alongside behavior and structure.</p><p>Coming from that context, reading about the right way to manage CSS felt like watching exciting evolution for a dated paradigm. A cleaner design for a horse harness is a beautiful thing but doesn’t beat the engine.</p><p>Solving the problem of chunked CSS delivery in order to get performance benefits from HTTP/2 sounds to me like reinventing the wheel from what you’re probably already doing. If you’re writing a web app, aren’t you already deploying well-separated HTML/JS chunks for the best performance? Why rebuild that process in parallel for CSS?</p><p>The core problem comes down to managing CSS inclusion/exclusion from the project through a human process. Let’s look at some consequences from keeping humans in the loop.</p><p>Here are some fallacies with the proposed setup:</p><h4>The Structure Works As Long As Devs Make It Work</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D-JJG5kb6nfpkl3jsjqPlg.png" /><figcaption><a href="https://www.viget.com/articles/managing-css-js-http-2">Source</a></figcaption></figure><p>The great file structure proposed in the article would help keep things organized. But who’s going to be responsible for keeping it that way? What if you simply didn’t need a process around maintenance because it took care of itself?</p><p>A problem that hasn’t been flatly solved by CSS tooling is code creep: when encapsulation is broken and styles are lost track of, living in perpetuity in the source code. The result is endlessly growing source code and convoluted strategies for keeping the delivered site in check (if you even try to mitigate the problem).</p><p>Sprinkling well-scoped CSS files into the HTML via &lt;body&gt; link tags sounds like a good solution. But who is maintaining the SCSS source files? Is your process strong enough to ensure that CSS creep will be negligible for the life of the project?</p><p>The security community revolves around the belief that removing humans from a process, and therefore removing the need to trust those humans, improves the overall security of a system by removing the human risk. Likewise, a style framework that removes the burden on human process to keep things tidy by nature won’t have CSS creep problems.</p><h4>We Can Just Strip Unused CSS</h4><p>If you have significant CSS baggage you might integrate tooling to strip dead CSS, but those tools have consequences too. If your site is dynamic then you have to ensure the stripper doesn’t strip the wrong code. Can you adequately maintain a well-scoped whitelist to make sure this doesn’t happen?</p><p>In contrast, with a CSS-in-JS setup unused code that makes it into the bundle gets stripped without consequence. The process is called dead code elimination; it’s a major selling point of Rollup and Webpack 2. No worrying about whitelists here.</p><h4>The Argument for CSS-in-JS Instead</h4><p>When was the last time you saw a project where the CSS had at least <em>some </em>untouchable baggage? Code that no one really knows what it impacts, and whose removal could have unintentional ripple effects? CSS and SCSS requires proactive management from the developers to keep it sane, and the moment that slips, it very quickly becomes easier to just never remove CSS.</p><p>Solving this problem is one place where the CSS-in-JS movement shines. Some common Javascript setups have fundamentally solved code baggage. If you stop importing a module because it is unused then all the whole module disappears from the project. It works well because JS modules are well encapsulated.</p><p>With a framework like React, you already have your “HTML” and business logic in the same place. So it cleans itself up when you remove the React logic. If you add styles to the mix then you gain that automatic organization for styling too.</p><p>At the same time you can retain the ability to write real CSS syntax, but with the added benefit of dynamic JS thrown in there. What if the idea of a &lt;Provider&gt; from the React world could drive your styling as well? Uniting styles with layout and business logic drives unexpected new synergies and a cleaner project.</p><p>If you simplified your project stack by removing CSS/SCSS, the benefits would pay big dividends. New talent would have less to learn. Devs would have fewer processes to follow and fewer things taking up mental bandwidth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JoMhKtROoEk3HMdo9FfN9Q.png" /><figcaption>Using syntax-highlighted styled components. Note easily interpolated dynamic values.</figcaption></figure><p>CSS-in-JS is a fast developing idea and different solutions have different drawbacks. I’ll never believe that writing CSS in JS syntax is as great as the CSS syntax was on its own. But some packages, like Styled Components, let you write a subset of real CSS syntax within your Javascript files. There’s editor plugins to retain syntax highlighting too.</p><p>Still though, switching to a subset of CSS is a big ask. What about pseudo-elements, media queries, animations, and so on? The answer from CSS-in-JS is still developing. Different CSS-in-JS packages have different coverage and approaches for CSS features. But to me, the benefits already outweigh the growing pains. And if you’re into universal apps (native rendering to every platform), then it is pretty cool to have styles that work through React and React Native across web, iOS, Android, and more with the same behavior.</p><p>When I read this article I couldn’t help but feel like I was seeing the evolution of a paradigm that’s been superseded. Check out CSS-in-JS and let me know where I’m wrong!</p><p>PS — also check out all the benefits of CSS-in-JS that I didn’t mention here, like loading only critical styles with each page load by default (again, don’t manage CSS in isolation when you already manage everything else).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9a58ad8b89" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Better Apps By Default]]></title>
            <link>https://medium.com/@chulcher/better-apps-by-default-f5a77ca4b9fb?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5a77ca4b9fb</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[desktop-app]]></category>
            <category><![CDATA[webpack-2]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Tue, 21 Feb 2017 18:57:34 GMT</pubDate>
            <atom:updated>2017-02-21T18:57:34.578Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*2BZfLbL2gDraI0zsA49qUg.png" /></figure><p>Summary: You can <a href="https://github.com/c-h-/universal-native-boilerplate"><strong>download my project</strong></a><strong> </strong>and use it as a starting point for your next app project. Once downloaded and configured, write your code in JavaScript (and native code if necessary). The <strong>code you write will work on every platform</strong>.</p><p>When you’re finished, run simple commands to compile and run the project on any major platform: Android, iOS, macOS, server-side rendering, Web, and Windows. When you’re ready to release your app to the world, you’ll find<strong> some optimizations are built-in</strong>, as well as a few tools to help you <strong>analyze and test</strong> your app. From there it’s up to you to sign and publish the app.</p><h3>Starting New Projects</h3><p>When I start new front-end projects I face the same problems every time:</p><ul><li>I have to set up a bunch of build tools before I can work on the app</li><li>Most starter projects cover some features I want and some I don’t, and never cover many platforms</li><li>No matter if I start from scratch or use a boilerplate, there are head-scratching hours/days of optimization and tuning ahead before compiled builds are production ready</li><li>Adding platforms, features, or code-base complexity later on frequently leads to refactoring in order to stay organized. What if it was organized with this complexity in mind to start?</li></ul><h3>What should a boilerplate do?</h3><p>So I set out to create a boilerplate that I could turn to again and again. It has to:</p><ul><li>Work well on every platform (native and web)</li><li>Get you to production with minimal hassle (out of the box optimized for real-world use)</li><li>Make built-in platforms and features by default disabled, but easy to enable. Make the developer opinionated where possible, not the boilerplate.</li><li>Be easy to write core code across platforms <em>and</em> easy to add platform-specific code. React Native handles most of this but it’s challenging to set up key common features. Well-organized navigation and data persistence need to be built-in. Community libraries, properly implemented, make this a reality.</li><li>Offer an (optional) command line interface that standardizes common commands across platforms. In other words, prevent these questions from happening: <em>How do I run my project on Windows again?? Was it </em><em>react-native build-ios? </em><em>.\gradle.bat assemble? </em><em>react-native-windows run-windows?</em></li><li>Assist in basic quality assurance with linting, testing, and reporting built-in. Make it straightforward to write standardized code, test platforms over time, and analyze the end results over time (bundle weight, usability testing, etc)</li></ul><p>I specifically did not try to solve problems which vary too much between projects and machines:</p><ul><li>Platform SDK setup (don’t attempt to set up a native platform for someone, like Android SDK or Universal Windows Platform SDK)</li><li>Deployment/publishing of apps (everyone has their own best way of releasing an app to the world)</li><li>Optimizations that incur too large a maintenance cost. Therefore, boilerplate optimizations should be set and forget or opt-in.</li></ul><h3>A New Boilerplate</h3><p>With those issues in mind, and a bit of elbow grease, I created <a href="https://github.com/c-h-/universal-native-boilerplate">Universal Native Boilerplate</a>. Then I used it to create an app to make sure it worked as expected. These are the features that come built-in:</p><ul><li>React and React Native support allowing for Android, iOS, macOS, Server, Web, and Windows platform support</li><li>A simple command line interface built on Gulp built to help throughout the project’s lifetime (e.g gulp enable ios, gulp run android, or gulp build web --release). Easy to extend by adding Gulp tasks (hint: add your own deployment as tasks).</li><li>Platforms and some features are off by default. Easy to enable with gulp enable &lt;recipe&gt;.</li><li>Basic app skeleton in place and organized well to grow with the app (includes native cross-platform navigation logic via react-navigation, and persistent state through redux and redux-persist).</li><li>Internationalization support</li></ul><p>And great web-specific features that modern web apps need:</p><ul><li>Progressive Web App enabled including offline support and lighthouse testing</li><li>Code optimizations like Webpack 2 tree shaking (dead code elimination), <a href="https://babeljs.io/docs/plugins/transform-react-inline-elements/">react class inlining</a>, and optimize-js to reduce start-up times (for most apps). It’s easy to add other optimizations you may prefer.</li><li>Great dev experience through hot module reloading (native-only) and a ready-to-use server for server-side rendering.</li></ul><h3>Wish list and Goals</h3><p>Some features, like <a href="https://github.com/Microsoft/react-native-code-push">app updates that bypass the app stores</a>, are easy to implement and project specific. These tools and plugins should be added by hand per-project, and never included in the boilerplate.</p><p>This boilerplate is most mature for Web and Android. It would be nice to have the Windows, iOS, and macOS platforms get the same love and treatment. Windows is the newest “official” React Native platform, and the macOS project mentions that there has yet to be a “success” story of an app built on the tech, so building real-world apps on those platforms should be considered new ground and taken with caution.</p><p>For Android, more optimization could be built-in well such as code signing and zip aligning, Proguard and <a href="http://fbredex.com/">Redex</a> optimization and obfuscation, and practical tips on avoiding crashes across the dizzying array of Android devices.</p><p>If Ahead of Time compilation is applicable and ever comes to React it would be great to reap those benefits in React projects. I’m unfamiliar with this feature, but I may do some experiments with <a href="https://github.com/toshok/echojs">echo-js</a> to see if it could be helpful in enabling this feature for React.</p><h3>Wrapping Up</h3><p>The final boilerplate makes great progress on my key goals. It’s easy to start a project and customize its platforms and features. I don’t have to remember precisely how every platform works to build and run the project. And the code is organized and standardized so that it’s more likely to last.</p><p>It was a blast and a challenge getting everything to click together to create this. This boilerplate contains years of experience mostly in web and Android, so it’s designed to avoid costly problems. Check it out and let me know what you think!</p><h4><a href="https://github.com/c-h-/universal-native-boilerplate">Universal Native Boilerplate</a></h4><p>Charlie Hulcher is Co-founder and CTO at <a href="https://upchannel.com/">UpChannel</a>, where we’re helping phone manufacturers provide first-class experiences to their customers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5a77ca4b9fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Plex Media Server on Edison -Weekend Hack]]></title>
            <link>https://medium.com/@chulcher/plex-media-server-on-edison-weekend-hack-da4351cc2e29?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/da4351cc2e29</guid>
            <category><![CDATA[raspberry-pi]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[plex]]></category>
            <category><![CDATA[intel-edison]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Mon, 13 Feb 2017 19:59:13 GMT</pubDate>
            <atom:updated>2017-02-13T19:59:13.633Z</atom:updated>
            <content:encoded><![CDATA[<p>I wanted to be able to simply turn on my TV, console, or computer and connect to my local media library (music, TV, and movies) without hassle and without buying new equipment.</p><p>I had an Intel Edison (similar to a Raspberry Pi or Arduino) that I didn’t have a need for so I decided to see how well that would do as a home media server.</p><p>A great service that is stable, mature, and free for running a media server is <a href="https://www.plex.tv/">Plex</a>.</p><h3>Replacing Edison’s OS with a Plex-compatible Version</h3><p>To run Plex on Edison I needed to get Debian Linux running instead of Yocto (the OS the board comes with). <em>Installing a new OS completely clears storage and formats the board. </em>A Debian distribution that works well on Edison is Ubilinux, a Debian version of Linux. This Sparkfun tutorial makes it easy to install: <a href="https://learn.sparkfun.com/tutorials/loading-debian-ubilinux-on-the-edison">https://learn.sparkfun.com/tutorials/loading-debian-ubilinux-on-the-edison</a>.</p><p>I set up Wifi on the box and ssh so that I could easily ssh in to manage the board.</p><h3>Getting Plex onto Edison</h3><p>Once Ubilinux was installed I installed Plex following these commands: <a href="https://forums.plex.tv/discussion/51427/plex-media-server-for-debian">https://forums.plex.tv/discussion/51427/plex-media-server-for-debian</a></p><h3>Restarting Plex after Reboot</h3><p>Note: after Plex was installed from the commands in the link above, I tried restarting the board to see if Plex would start automatically. It didn’t so I manually added a bash script and registered it to run automatically to start Plex. Here’s a good post on how to do that: <a href="https://www.cyberciti.biz/tips/linux-how-to-run-a-command-when-boots-up.html">https://www.cyberciti.biz/tips/linux-how-to-run-a-command-when-boots-up.html</a></p><h3>Accessing Plex Web Interface</h3><p>With Plex installed and running I was able to access the server from my web browser on my laptop. I ran ifconfig to get the local IP address of the Edison board (192.168.x.x), and then visited that IP with the following address on my laptop’s web browser: <a href="http://192.168.x.x:32400/web/">http://192.168.x.x:32400/web/</a>. From there I followed the on-screen instructions to set up.</p><h3>Mounting Storage with Media Files</h3><p>With all of that done, I switched my Edison’s USB host switch so that the larger USB port started functioning and plugged in a 512GB flash drive containing my library. The flash drive is exFAT formatted, a format that Ubilinux can read and write to. Once plugged in I mounted the drive to a local folder. I added this mounting step as the first step of my startup script that starts Plex media server as well. This ensures that the drive will be there with the media and the server’s files (see note below) when Plex starts.</p><blockquote><strong>Important: </strong>It took me 2 tries to get my Edison working. The first time, after I had set everything up, Plex downloaded so much metadata to the Edison that it completely filled the small amount of storage space on the board. After clearing the metadata everything got messed up and reinstalling wasn’t enough so I had to flash the Ubilinux OS <strong>again </strong>before restarting. To avoid this happening to you: after you install and run Plex, shut it down completely (close any Plex processes so you’re sure it’s not running). Then move the Plex folder from /var/lib/plexmediaserver on the Edison to a folder on your flash drive. Then link the folder on the flash drive to where you moved it from: ln /mnt/e/plexmediaserver /var/lib/plexmediaserver. Now Plex will save all of its data to your flash drive instead of the Edison board and you won’t run out of space.</blockquote><h3>Add Media Libraries</h3><p>With all of this done it was time for the home stretch: opening the Plex server web page on my laptop once more and adding the libraries from my flash drive (navigating to the locally mounted folder on the Edison to find them). As part of this process I re-organized my files so they fit Plex’s media structure better so metadata would be downloaded correctly.</p><h3>Finally, Connecting and Watching Media</h3><p>Now that the server was all set up all I had to do was enter the server’s IP address into my Plex apps on my laptops, phones, and consoles. There’s a bit of lag between when videos are selected to play and they start playing but other than that it operates just fine. The startup script makes it resilient to restarts and so far the IP address hasn’t changed so I haven’t had to redo any connections.</p><h3>Bonus: Managing Media Library from Laptop</h3><p>Lastly, as a bonus I wanted to be able to easily manage my flash drive’s library without unplugging it from the Edison or ssh’ing in or using scp. I found this post which introduced me to Samba: <a href="http://www.howtogeek.com/176471/how-to-share-files-between-windows-and-linux/">http://www.howtogeek.com/176471/how-to-share-files-between-windows-and-linux/</a></p><p>With Samba I was able to mount the folder on my Edison where the media is mounted to my laptops and easily manage the folder just like normal. With that done, I could put the Edison into a box and stick it on a shelf.</p><p>I’ve been using the Edison-based server for a few weeks and only had to restart it once when it wasn’t responding. Very happy with how this hack ended up.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da4351cc2e29" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Launcher Boilerplate]]></title>
            <link>https://medium.com/@chulcher/standalone-android-launcher-553b4be805b2?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/553b4be805b2</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[aosp]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[google]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Fri, 11 Nov 2016 22:34:25 GMT</pubDate>
            <atom:updated>2016-11-11T22:37:59.521Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*GOTPVnPOFJ8hiiOXGNe92w.png" /></figure><p>I’ve taken the most recent default Android Launcher and made it available as an easy to compile standalone, boilerplate project.</p><p>The <a href="https://github.com/c-h-/standalone-android-launcher3">Git repository</a> is ready to be cloned and compiled using Android Studio. The finished .apk application is compatible with Android versions 5+. <strong>It’s a great starting point to build a new launcher!</strong></p><p>Through the <a href="https://source.android.com/">Android Open Source Project</a> (AOSP), from Google, you can find all kinds of interesting code.</p><p>If you want to build a new Android Launcher application, a good place to start would be the launchers that are already available open source with permissive licenses.</p><p>There are three available from AOSP, each replacing the last as the current default Android launcher: Launcher, Launcher2, and Launcher3.</p><p>I took the 7th revision of the 5.0.0 release of Launcher3 and modified it to compile easily using Android Studio.</p><p>Follow these instructions to get the source and build it yourself:</p><ol><li>Make sure you have Android SDK installed with 5.0.0</li><li>Make sure you have Java 8 JDK (I’d recommend the jenv tool to manage multiple JDK installations)</li><li>git clone <a href="https://github.com/c-h-/standalone-android-launcher3">https://github.com/c-h-/standalone-android-launcher3</a></li><li>Open the cloned project in Android Studio</li><li>Build it!</li></ol><p>By Charlie Hulcher <a href="https://charlie.engineer/">https://charlie.engineer</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=553b4be805b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creating an Android-enabled Robot Operating System Embedded Cluster]]></title>
            <link>https://medium.com/@chulcher/creating-an-android-enabled-robot-operating-system-embedded-cluster-d030069b7bfc?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/d030069b7bfc</guid>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[embedded-systems]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Tue, 10 May 2016 21:19:28 GMT</pubDate>
            <atom:updated>2016-05-10T21:19:28.269Z</atom:updated>
            <content:encoded><![CDATA[<p>The economy and capability of Android devices paired with the Robot Operating System (ROS) software framework is a very powerful combination for building distributed robotics applications.</p><p>For example, you could create an autonomous lawn-care robot controlled by a master board (like a Raspberry Pi or Intel Edison), that coordinates sensor gathering from low-cost Android devices, pulls sensor readings from LIDAR scanners or image systems, and puts it all together to understand its environment and take action.</p><p>This high-level guide walks through setting up an embedded development board with a full installation of Robot Operating System, then an ROS-enabled Android development environment on a computer, and finally a simple ROS subscriber (residing on the board) that listens to sensor data published to ROS topics by an ROS-enabled Android application.</p><h3>Orientation</h3><h4>Pieces of the Puzzle</h4><ul><li>A development board (Guide uses Intel Edison. Raspberry Pi should work even better, but you’re on your own for setup)</li><li>An Android device</li><li>A computer (for development)</li></ul><p>The application that will run the robot can be thought of as a collection of scripts (called “nodes”) that communicate with each other to accomplish a task. A node can exist on any connected device in a cluster.</p><h4>The End Goal</h4><p>The setup this guide creates is a single development board which runs the Robot Operating System master and a subscriber node, as well as an Android application that acts as a connected publisher node. As a side-effect of this guide, you will have a complete Android development environment on a computer, and a complete ROS development environment located on the board itself.</p><p>The example software we will be running is an Android application that “publishes” sensor data that it collects to ROS “topics”, which is how ROS segments “messages”. The subscriber node “subscribes” to the topics that the Android app publishes to.</p><p>Since the subscriber node knows the format of the messages in the topics that it subscribes to, it can immediately use those data structures to complete further activities (those further activities are beyond the scope of this guide).</p><h3>Getting Started</h3><p>These are the things we need to accomplish:</p><ul><li>Install an ROS-compatible distribution of Linux on a board</li><li>Install and configure ROS on a board</li><li>Install an Android development environment on a computer</li><li>Compile and install the Android app onto a device</li><li>Compile and run the board-based ROS nodes</li><li>Watch as sensor readings appear on the board from the device!</li></ul><h3>Configure the Development Board</h3><h4>Installing a Compatible Version of Linux</h4><p>To install Robot Operating System on the Intel Edison, the board needs to be flashed with a more fully-featured distribution of Linux.</p><blockquote><a href="https://medium.com/@chulcher/34fe8fc47ac1">Follow this guide</a> to install Ubilinux onto your Edison board.</blockquote><h3>Install Robot Operating System</h3><h4>Installing and Configuring Robot Operating System on Ubilinux Edison</h4><p>Installing and properly configuring Robot Operating System on Ubilinux Edison can be a very challenging task. A guide has been created to walk you through the process, and some installation scripts are provided that <em>may </em>make the process quite smooth. If the scripts do not fully install and configure ROS, then see the source code of the scripts to see what needs to be done and what is going wrong.</p><blockquote><a href="https://medium.com/@chulcher/448900b6ef60">Follow this guide</a> to install ROS onto your Ubilinux Edison board.</blockquote><h3>Set Up Android Development</h3><h4>Creating an ROS-enabled Android Environment and Subscriber Application</h4><p>Android development can be tricky to get started with, let alone integrating Robot Operating System into an application.</p><p>A pre-configured development environment and sample ROS-enabled applications are available on Github and a guide to installing the environment and using it is published on Medium.</p><p><em>The technical details: Needed ROS building blocks are pulled down from Maven, builds are orchestrated with Gradle, and Android API 15 is targeted to allow broad support and Mac OS X development capability.</em></p><blockquote><a href="https://medium.com/@chulcher/7bf1323bf78f">Follow this guide</a> to set up Android Development on a computer.</blockquote><p>Phew! That was a lot of work. With all of that out of the way, let’s see how to use our new set up:</p><h3>Putting It All Together</h3><h4>Developing For and Using the ROS/Android Cluster</h4><p>The best way to develop ROS nodes that should reside on the development board is to mount the board over SFTP with an application like <a href="https://cyberduck.io/?l=en">Cyberduck</a>. This lets you edit and sync files on the development board via a computer over Wifi.</p><ul><li>Connect your computer and board to the same wifi network</li><li>Get your board’s IP address (run ‘ifconfig’ and get the inet address under wlan0)</li><li>Create a new bookmark on Cyberduck. Add the IP address.</li><li>Set the username to root and password to Edison</li></ul><p>To start Robot Operating system, run:</p><pre>cd ~/ros_catkin_ws<br>roscore</pre><p>And leave that running while you want your nodes to work. In a separate terminal or process, to start the sample Android app subscriber that will output selected sensor readings from the app run:</p><pre>cd ~/ros_catkin_ws<br>rosrun beginner_tutorials android_subscriber.py</pre><p>To send sensor readings to the ROS master, and therefore to the subscriber to output them to the screen, install the android_sensors_driver sample app onto an Android device. Set the device to the same wifi network as the board. Get the IP address of the board.</p><p>Then input the IP address and default port (11311) into the text field of the Android application. Here’s an example completed address:</p><pre>http://192.168.1.1:11311</pre><p>With all of those running and connected you should see sensor readings streaming on the console that you ran the android_subscriber on!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d030069b7bfc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting up Robot Operating System on Intel Edison]]></title>
            <link>https://medium.com/@chulcher/setting-up-robot-operating-system-on-intel-edison-448900b6ef60?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/448900b6ef60</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[intel-edison]]></category>
            <category><![CDATA[robotics]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Tue, 10 May 2016 21:18:39 GMT</pubDate>
            <atom:updated>2016-05-10T21:18:39.425Z</atom:updated>
            <content:encoded><![CDATA[<p>To build complex robotics projects, it’s typically wise to use the Robot Operating System collection of software frameworks.</p><p>This guide walks through doing a full installation of Robot Operating System (indigo version) on a fresh installation of Ubilinux based on an Intel Edison board. The installation is a modified process of installing ROS on Raspberry Pi in a way that works for the Edison.</p><blockquote>Important Note: If your <strong>Intel Edison </strong>has not been flashed with the Ubilinux distribution, then <strong>this installation will fail</strong>. Refer to <a href="https://medium.com/@chulcher/34fe8fc47ac1">this guide</a> to replace the stock operating system, Yocto, with Ubilinux.</blockquote><p>Referenced at the end of the guide is some additional configuration to install common message formats to speed common publisher/subscriber development. Also at the end of the guide is instructions on how to install a basic subscriber script that can listen to and understand sensor readings from an ROS-enabled Android application.</p><h3>Run the Install Scripts</h3><p>Install scripts have been created that codify the necessary steps to install ROS on a fresh Ubilinux Edison. <a href="https://github.com/c-h-/edison_install_ros.git">The scripts are on Github.</a></p><p>To do the installation, we will need to:</p><ul><li>Get the scripts onto a computer</li><li>Run the scripts on the board over USB or transfer them onto the board to run them there</li></ul><p>On a computer:</p><pre>git clone <a href="https://github.com/c-h-/edison_install_ros.git">https://github.com/c-h-/edison_install_ros.git</a><br>cd edison_install_ros</pre><p>To run the scripts over USB on the connected Edison board (both USBs connected):</p><pre>./run_on_host.sh</pre><p>— OR —</p><p>To run the scripts on the device itself:</p><p>Connect to the device and copy run_on_ubilinux_edison.sh and run_on_ubilinux_edison_part_2.sh onto the device at ~/.</p><pre>./run_on_ubilinux_edison.sh</pre><p>If that completes successfully, then you’re done!</p><h4>Troubleshooting</h4><p><strong>Running the install script fails</strong></p><p>Diagnose the error reported, fix it if possible, and re-run the installer script.</p><p><strong>I cannot figure out how to fix an error</strong></p><p>The commands that run to install Robot Operating System output to the screen as they are run. Determine which command is failing, then look at the install script in a text editor. The comments there should tell you what is trying to be accomplished. Figure out how to accomplish that thing, then run the next commands.</p><h3>Orientation to Robot Operating System</h3><p>At this point, you should have a folder at ~/ros_catkin_ws. This is your Robot Operating System workspace folder. For future reference, it is a catkin workspace (there are different kinds). The installation type you have is Indigo. Install new “stacks” (collections of packages and dependencies) and new “packages” into the src folder of your workspace: ~/ros_catkin_ws/src.</p><p>In ~/ros_catkin_ws/src there should be folders:</p><ul><li>common_msgs</li><li>begineer_tutorials</li></ul><p>The common_msgs folder is where commonly used message definitions have been installed. The beginner_tutorials folder is where a series of tutorials have been installed.</p><p>If you edit any scripts, install anything, or otherwise change the workspace setup, run the following to rebuild:</p><pre>catkin_make</pre><p>If you are connecting the Android Sensors Driver application to your new ROS Master node, run the following commands in different processes (Terminal windows):</p><pre>roscore<br># (in new window)<br>rosrun beginner_tutorials android_subscriber.py</pre><p>Those two commands start ROS and then run the Android subscriber to listen to sensor messages.</p><p>Connect the Android app to the ROS master by putting the Android device and board on the same wifi network, then entering the IP of the board’s wlan0 interface with the default ROS port (11311) into the Android application.</p><p>To get IP address of the board:</p><pre>ifconfig</pre><p>Then look for “inet” under “wlan0”. Something like 192.168.1.1 probably.</p><p>To connect app to board:</p><p>Enter something like: http://192.168.1.1:11311 into the text field of the app, where you replace the IP you found on your board.</p><h3>Developing Your Own Nodes</h3><p>I would recommend developing nodes that talk to the Android sensors driver application starting from the android_subscriber.py sample node.</p><p>The node is located at:</p><pre>~/ros_catkin_ws/src/beginner_tutorials/scripts/android_subscriber.py</pre><p>Let me know what you build!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=448900b6ef60" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing ROS-Enabled Android Applications]]></title>
            <link>https://medium.com/@chulcher/developing-ros-enabled-android-applications-7bf1323bf78f?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bf1323bf78f</guid>
            <category><![CDATA[sensors]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[robotics]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Tue, 10 May 2016 21:17:59 GMT</pubDate>
            <atom:updated>2016-05-10T21:17:59.619Z</atom:updated>
            <content:encoded><![CDATA[<p>Robot Operating System is a powerful framework choice for developing distributed robotics applications.</p><p>The explosion of affordable Android devices are a boon to robotics development: these devices are fully integrated sensor beds with human facing interfaces built-in, a mature ecosystem of technology to power Android applications, a large talent market that can work with Android, and huge cost efficiencies for sourcing the hardware (Android devices have dropped below $50/unit globally).</p><p>With Robot Operating System and the Android ecosystem, you can quickly create a cluster of computing devices that utilize the best of each device to accomplish robotics tasks, such as sensing, image processing, networking, and more.</p><p>This guide walks through setting up an Android development environment that can utilize Robotics Operating System capabilities <strong>without </strong>a local installation of ROS. The environment <strong>does not require</strong> Android Studio or Eclipse.</p><p>At the conclusion of this guide you will have a fully configured Android application development environment that is ROS-enabled. As a bonus, a collection of applications that demonstrate basic integration with Robot Operating System is included. One of the applications publishes sensor data to ROS topics for subscription by other ROS nodes in a cluster, allowing you to quickly start reading Android sensor data from a node if that is your goal.</p><h3>Get the Pre-Configured Dev. Environment</h3><p>A development environment exists and has been put together that includes sample applications that utilize ROS integration, build commands to create the applications, and support for various operating systems.</p><p><a href="https://github.com/c-h-/android_core/tree/indigo">The development environment is on Github.</a></p><h4>Getting the Environment</h4><p>To set up the environment, somewhere on your computer, run the follow commands:</p><pre>git clone https://github.com/c-h-/android_core<br>cd android_core<br>git checkout indigo<br>git submodule update --init --recursive</pre><p>This makes a local copy of the environment and the sample applications configured to work with Robot Operating System Indigo version.</p><h4>Setting Up Android</h4><p>To compile an application for Android, the Android SDK and associated tools are required. The easiest way to install the Android SDK on Mac OS X is to:</p><pre>brew install android-sdk</pre><p>If you see “brew: command not found”, then you need to install the <a href="http://brew.sh/">Homebrew package manager</a>.</p><p>With the SDK installed, next we need to get the SDK tools for the API we’re targeting (15) and the Build Tools version we need (21.1.2).</p><p>Run the following command:</p><pre>android</pre><p>A window should appear that shows various installed SDK packages:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sWWj_RugkKjZ6IFz2_wcxg.png" /></figure><p>Find and install:</p><ul><li>Tools -&gt; Android SDK Build-tools 21.1.2</li><li>Android 4.0.3 (API 15) -&gt; SDK Platform</li></ul><p>And you’re done!</p><h3>Compiling the Sample Applications</h3><p>With the environment installed, now let’s test building the sample applications we have in our environment.</p><p>From the folder where you installed the environment (probably called android_core) you can run the <a href="http://gradle.org/">Gradle</a> commands that manage compilation.</p><pre>./gradlew assembleDebug<br>./gradlew assembleRelease<br>./gradlew clean</pre><p>The assembleDebug command compiles the applications in debug mode. The assembleRelease command compiles the applications for release (but does not sign and align them, see Android Documentation for how to do that). The clean command cleans out build files.</p><p>Built application files for each application are in the build/outputs/apk folder of each application.</p><p>Try running ./gradlew assembleDebug and see if this file exists:</p><p>…./android_core/android_sensors_driver/build/outputs/apk/android_sensors_driver-debug.apk</p><p>If so, you’ve built the application successfully.</p><p>You can build, install, and launch the android_sensors_driver application with a script:</p><pre>cd android_sensors_driver<br>./build_and_run.sh</pre><p>Look inside the build_and_run.sh file to see the commands to run those steps yourself.</p><p>To connect the android_sensors_driver application to an Android subscriber that will listen for the topics published by the app, <a href="https://medium.com/@chulcher/448900b6ef60">see this guide</a> (particularly the end).</p><h3>Developing Your Own ROS-Enabled Applications</h3><p>I would recommend using the android_sensors_driver application as a starting point to develop your own applications. It already contains the code to publish sensor readings to the master node, and the user interface to configure that connection.</p><p>Let me know what you build!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bf1323bf78f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Installing Ubilinux on Intel Edison]]></title>
            <link>https://medium.com/@chulcher/installing-ubilinux-on-intel-edison-34fe8fc47ac1?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/34fe8fc47ac1</guid>
            <category><![CDATA[intel-edison]]></category>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Tue, 10 May 2016 21:16:43 GMT</pubDate>
            <atom:updated>2016-05-10T21:17:22.967Z</atom:updated>
            <content:encoded><![CDATA[<p>The Intel Edison comes pre-installed with Yocto, an embedded Linux distribution. This operating system is fine for some tasks, but to do serious development requires a full-featured Linux installation.</p><p>Luckily, Ubilinux is compatible for installation on the Edison. My goal with this installation was to have an operating system that could be a suitable target for installing Robot Operating System through an automated board stand-up process.</p><p>Follow this guide to learn how to install Ubilinux on Edison. If you want to install Robot Operating System onto Ubilinux Edison, see the guide linked at the end of this post. Additionally, there is a guide to getting started with ROS-enabled Android development at the end as well.</p><blockquote>Important Note: Performing this <strong>installation will completely wipe </strong>the Edison. Before continuing, make backups of all important data. Programs developed to work on the Edison before this install may not work afterwards since the operating system environment will change.</blockquote><blockquote><a href="https://learn.sparkfun.com/tutorials/loading-debian-ubilinux-on-the-edison">This guide is the best source for installing Ubilinux on Edison</a></blockquote><h4>Additional Thoughts</h4><p>It turns out that the flashing software is incompatible with Mac OS X as of the writing of this post. You will need a Windows or Linux machine to flash the board.</p><p>The install files are quite large. Create a designated place on your computer to perform the install and then clear it afterwards to save space.</p><p>Networking set up can be a little wonky after the install. Make sure you have a loopback interface and the wlan0 interface is configured correctly. See /etc/network/interfaces to set these up.</p><p>Default username and password should be root/edison.</p><p>Operating the Edison over a screen interface can introduce issues with programs that take control of output, such as editors. Use SSH to connect to and command your Edison for a better experience that won’t introduce as many errors.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34fe8fc47ac1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coding is Creative]]></title>
            <link>https://medium.com/@chulcher/coding-is-creative-c85b7566a41b?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c85b7566a41b</guid>
            <category><![CDATA[art]]></category>
            <category><![CDATA[creativity]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Sat, 09 Apr 2016 18:16:45 GMT</pubDate>
            <atom:updated>2016-04-09T18:16:45.756Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CDPUxBVadBuPVFZ58dCXbQ.jpeg" /></figure><p>When you think about programming (or coding), you might not consider it to be a creative pursuit. That’s a viewpoint that I, as a coder, was very confused by, because I see it as one of the better avenues for creativity available today.</p><p>I hope this piece changes the way you think about programming and encourages further exploration.</p><blockquote>Programming as a creative outlet can be understood by comparing it to traditional artistic pursuit.</blockquote><h3>Becoming an Artist</h3><h4>Starting with Charcoal</h4><p>Imagine you’re a new artist. You’ve decided to start drawing, and you want to start with charcoal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RuLDPgtKVlxMimNGhhyfew.jpeg" /><figcaption>From <a href="https://en.wikipedia.org/wiki/Charcoal_(art)">https://en.wikipedia.org/wiki/Charcoal_(art)</a></figcaption></figure><p>You feel the charcoal in your hands, the dusty but smooth texture, and the large thick pad of paper you’ll be applying it to. It may strike you that you have no idea how to use these tools to accurately represent the vision of artistic beauty inside you.</p><p>You start the piece anyway. As you lay down strokes, discovering how different charcoal is from pencil, it really starts to sink that this is something completely new you’ll have to master. It really sinks in when you reflexively try to erase a stroke that’s inaccurate, laying down smudge wherever you spread the stroke out.</p><p>You come to realize it will take <em>years</em> of difficult work, self-discipline and self-discovery, and learning from all kinds of different sources you never considered, before you’ll be able to use charcoal for creative expression that matches closely to your original intent.</p><h4>The Artistic Problem</h4><p>When you started, you faced a problem as an artist: there was an original, artistic vision of beauty in your mind that you wanted to bring into the world. You found an outlet that can help you express that vision.</p><p>But when you went to implement the vision in real form, you ran into new problems.</p><p>Drawing with charcoal, or any means of expression in real life, comes with constraints, or rules, that must be <em>mastered </em>to most faithfully represent your artistic vision in the real world. Until you understand what the rules are, which rules to break, and when, you’ll create expressions that are inadequate compared to the mental vision (which is quite frustrating!).</p><blockquote>Tools and techniques exist to help the artist realize their creative vision, not as a means to create it for them.</blockquote><p>Artists are not stewards of the creations that their tools have wrought, but rather the creators themselves, aided by their tools.</p><p>Even the most talented master of a form may still have reservations about the ability of their works to convey the meaning, intent, and emotion of the original vision.</p><p><strong>So how does programming compare to this journey?</strong></p><h3>Programming is Artistic Expression</h3><p>The exercise we just went through can be very reflective of a programmer’s journey towards mastery.</p><p>A programmer faces a problem: some condition or process in the world is imperfect. It’s now the programmer’s job to envision possible solutions to that problem.</p><p>The same as any other artist, the programmer faces very real rules that dictate what kind of visionary solutions are possible. The best, most creative and clever programmers oftentimes have a masterful understanding of the rules that dictate what is possible to enact in real form, and a mastery of the computer tools that offer a means of expressing that beautiful solution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3sRiMhMytVuujQCN07wKkg.jpeg" /></figure><p>What makes programming a particularly exciting and invigorating outlet for creative expression is actually the rules that govern it. When drawing with charcoal, there are limits on what you can do with a piece of charcoal and paper. Those limits <em>do not </em>limit the ability of an artist to create a perfect work of beauty; but rather pathway in which that beautiful work can be realized is in itself limited.</p><p>In the same way, the laws of physics govern the ability of programmers to enact their solution to a problem. If there is no way to express logically a solution to an existing problem, then that problem is a poor fit for the physics-based logical world of programming.</p><blockquote>The trick is that most every problem can be solved through a creative logical expression.</blockquote><p>Where the art, beauty, and raw creativity of a visionary programmer shines through is in finding the simplest, most pure, most elegant logical expression which solves a problem.</p><h4>One Step Further</h4><p>This comparison continues. When you think of paintings or other traditional forms, you quickly think of the categories and disciplines to which they belong.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H_BeENeErK0bgAfvr8tOlA.jpeg" /><figcaption>PD-US, <a href="https://en.wikipedia.org/w/index.php?curid=38782663">https://en.wikipedia.org/w/index.php?curid=38782663</a></figcaption></figure><p>Surrealism, realism, cubism, modern, etc. are all movements that capture ideologies of how to best express visions in real forms.</p><p>These forms can be powerfully perceived by others when expressed under an ideology that introduces purposeful new constraints on how vision is to be expressed. Artistic movements create paths toward repeatable practices that help artists express the essence of their vision, They help subdue the inadequacy of any particular medium impeding a vision’s accurate representation. In other words, ideologies from artistic movements aid artists in solving the problem of accurate expression and helps best use the strengths of imperfect mediums to express ideas.</p><h4>Programmers have Movements, too</h4><p>Programmers are invigorated by co-existing and continuously evolving ideologies, tools, and technologies. They offer similar support to programmers as artistic movements offer support to traditional artists.</p><p>Coders pick programming languages, patterns of logical expression, and high-level design patterns that help them envision and implement solutions to different kinds of problems. By learning some of these different tools and ideologies, the programmer becomes better equipped to represent their vision faithfully without being encumbered by the inadequacy of specific tools and techniques.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*-yQKNXV37BPQDs_Thq6Aog.jpeg" /><figcaption>By Source, Fair use, <a href="https://en.wikipedia.org/w/index.php?curid=35971938">https://en.wikipedia.org/w/index.php?curid=35971938</a></figcaption></figure><p>Sometimes a modern art painting best expresses an abstract concept or emotion, sometimes realism magnifies and focuses the perceived world’s inherit beauty. Programmers pick their tooling and chosen ideologies for problems that help them best solve different kinds of problems.</p><h3>Why Choose To Program</h3><p>When most computer scientists and engineers first begin their journey, I doubt most consider the artistic aspect of the work, but rather the self-realizing power of the pursuit.</p><blockquote>“Music can change the world because it can change people.”<br>- Bono</blockquote><p>Similar words that an artist could say about the power of music or painting or other artistic expression can be said about programming.</p><p>The distinction that’s differently attractive about engineering and programming is its ability to change the organization of human society, and thereby affect the senses and psychology of individuals vs the other way around for traditional art forms. The best traditional art galvanizes people to enact societal change as a result of their inner change whereas engineering affects the fabric of society itself directly through its implementation, and those changes can effect people’s psychology, if less directly.</p><p>Software and engineering underpin the way that every human being lives their lives across the world. When architecture or banking software or other foundational underpinnings change, those changes quite literally change the world as it relies on those foundations.</p><p>To have the power to even be a small part of societal change could be why you choose to be an engineer or programmer. It’s one of the most demanding and difficult jobs because of the physical limitations and worldly impact of the work. The same can be said about any artistic profession or pursuit; it’s only the <em>kind</em> of world change that is likely to result from the engineering pursuit that’s different.</p><h3>Reality</h3><p>Anecdotally, in my life I know this holds true. I think it is no coincidence that at <a href="http://upchannel.com/">UpChannel</a> 3 of the first 5 engineers have musical backgrounds and are active creators. (<a href="http://upchannel.com/careers/">Want to join us?</a>)</p><p>It is that curious spirit and desire to change the world through beautiful creative expression that drives the most creative people I know.</p><p>So artists and programmers face very similar paths, have similar concepts of using ideology and mediums as different tools to solve problems, and the outcomes of their works are similar. I think it’s fair to say that programmers <em>are</em> artists, and their work requires similar talents.</p><p><strong>Is this theory of coding as art useful? Is it completely wrong? What do you think?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c85b7566a41b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build Real World Tech]]></title>
            <link>https://medium.com/@chulcher/build-real-world-tech-53083ee3d4ad?source=rss-f59083ff4d5d------2</link>
            <guid isPermaLink="false">https://medium.com/p/53083ee3d4ad</guid>
            <category><![CDATA[apps]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Charlie Hulcher]]></dc:creator>
            <pubDate>Sun, 22 Mar 2015 02:11:39 GMT</pubDate>
            <atom:updated>2015-03-22T02:11:39.561Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>From AppCow Engineering</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*kYs80npGl3QZWjKxjOeV3A.jpeg" /></figure><p>At AppCow we’re striving to bring the best experience to everyone we serve. Period.</p><p>From an engineering standpoint this is a difficult thing to pull off. Sometimes things don’t work as you’d expect in the hands of people that aren’t on your team. Sometimes you need to revisit the assumptions you’ve made designing and implementing your product. But each time there’s a problem, there’s a chance someone will be unhappy with their experience. How can we make sure this happens as rarely as possible?</p><h3>Debugging</h3><p>That’s where <strong>debugging and testing</strong> comes in! It’s the first step towards releasing a product that the most people are happy with. Us developers have incredible tools at our disposal to find, diagnose, and fix bugs and errors in our apps before they ship. This is especially true for web technology: <a href="https://developer.chrome.com/home/devtools-pillar">Chrome’s Dev Tools</a> are the envy of the programming world.</p><p>So you’ve got the best equipment, the latest, bleeding edge tech and best practices, and you’re ready to start testing and debugging.</p><blockquote><em>Ready to go?</em></blockquote><blockquote><em>Not quite.</em></blockquote><p>When we took a look at the versions and kinds of devices that were using our MVP app, it became quickly apparent that we’d need to be a bit more creative in our approach.</p><p>The problem is that Chrome Dev Tools has remote debugging now, but only starting in Android 4.4. D’oh! <strong>Plenty</strong> of our users weren’t quite there yet, and it’s usually true that the oldest devices have the most bugs. We couldn’t just ignore so many of our users, so we needed a better strategy.</p><p>We ended up using a tool called <a href="https://people.apache.org/~pmuellr/weinre/docs/latest/"><strong>Weinre</strong></a> for realtime remote debugging. It isn’t perfect, or as sophisticated as Chrome Dev Tools, but it allowed us to make experience breakthroughs on our most troublesome devices that wouldn’t have been possible without it.</p><h3>Real-world Device Testing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yDxzACbgJF1vYsWTvyiAHA.jpeg" /><figcaption>Androids massing</figcaption></figure><p>Our amazing Android device testing lab is stocked with devices that are representative of our real users thanks to our partner <a href="http://poshmobile.com/"><strong>Posh Mobile</strong></a>. I spend quite a lot of time with those devices. Having access to a physical device lab is critical to getting the most out of device testing: virtual device and remote physical device testing should be <em>just the start </em>before you do real, in-your-hands testing of your app.</p><h3>Beta Testing</h3><p>The qualitative feedback you get from users before your app goes live can make the experience actually work when it’s time for production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*jIX_Oy3PuJatcPl3JHLUow.jpeg" /><figcaption>Beta “Testing”</figcaption></figure><h4>In Person Sessions</h4><p>Once you’ve ironed out all the bugs you can, it’s time to get it in the hands of real users. Having actual users in the development loop will help ensure you’re actually improving the product you’re developing. In true startup fashion, we found that enticing testers with <strong>free pizza</strong> was the best way to get people in and playing with our product. But:</p><blockquote><em>Free pizza isn’t enough</em></blockquote><p>Before your users arrive you should have beta devices lined up, test cases to walkthrough, and suggested activities. Leave them room to explore on their own, but have them walk through the experiences you most expect to find pain points with. Collect ALL of the feedback you can — worry about processing it later. And most importantly you’re trying to get their true impressions and feelings about your product. Avoid giving direct instructions — try to guide only when necessary, and give the minimum input to get a user going again if they get stuck.</p><h4>Beta Testing Community</h4><p>Long term, it’s best to have a dedicated group of users that is excited to test the latest releases of your app. These early adopters (definitely should be actual app users) will give you invaluable feedback about your app before it’s ready for the production push. We’re very excited for the role our Beta testing community will have with us going forward.</p><h4>And Beyond</h4><p>Using <strong>Fiverr</strong> we continue to multiply the debugging effort that our team alone could produce. It’s amazing to go to bed satisfied that you’ve crushed a ton of bugs and made the product better and then waking up with fresh reports from testers around the world.</p><h3>Lessons Learned</h3><ol><li>Investigate where and how your app will actually be used <strong>before building</strong></li><li><strong>Find the best tools for the problem you have</strong>, not the problem you wish you had</li><li>There’s no substitute for <strong>hands-on access</strong> to your app on real devices</li><li>You can never get too much <strong>beta testing feedback</strong></li><li>The most impactful work you can do is not <strong>build new features</strong>, but rather make sure features are actually<strong> working as intended</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/294/1*ZHsfTMCEUhShgnwiUjnUkQ.png" /><figcaption>Thanks for reading!</figcaption></figure><p>Want to beta test our new app? <strong>Join our </strong><a href="https://plus.google.com/communities/108595781783064176288"><strong>beta testing community</strong></a><strong>!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53083ee3d4ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>