Dev Continuum

iPod Classic Revival

Tue, 29 Mar 2022 05:24:00 GMT

I’ve always had my hand in electronics since I was a kid, digging through boxes and finding some old device, such as a Camera that was five times my age. My curiosity always got the best of me, and I’d end up with a table full of parts by the end of the night, trying to determine which one was preventing the device from functioning. I found myself recently experiencing this same child-like adventure, after unpacking a box of old electronics in my basement. I came across an old iPod 4th Generation, and after rummaging around for a cable, and painfully waiting to see if the battery still functioned, I discovered that it was in fact dead.

Research#

To begin diagnosing the problem, I decided I would charge it for 5 hours, unplug it, and then let it rest for 30 minutes. Then finally, charge for another 5 hours. After having completed this cycle, I held down MENU + SELECT simultaneously, and I could hear the disk spinning up and down. With each “wurr” of the hard drive, it was as if it was attempting to come to life, but could not. The screen was blank and soulless, and I wasn’t quite sure exactly how a 20 year old device that held the secrets of my childhood playlists could possibly function again.

I was relatively sure that the hard drive could be fixed, and that the battery had some amount of juice in it. I assumed that either the headphone jack was broken (since if it was stuck in HOLD it would not respond to button presses), or that the clickwheel itself had malfunctioned. Additionally, the screen was not turning on, and did not show a charging indicator. So I knew something else must have been wrong. To determine what exactly was going on, I would have to find a way to open the iPod and diagnose the issue further.

Fortunately, this is not the first time I have attempted a fix like this, and I have some great tools I’ve collected over the years from upgrading phones or fixing electrical tools. iFixit’s Mako Driver Kit ($35 at the time of writing), is a wonderful bit set that I find invaluable for these types of tear downs of small devices. It has so many different bits, and I’ve used it now to repair, chainsaws, phones, consoles, handhelds, speakers and more.

Opening the iPod required finding a thin jig, ideally made of plastic and not too hard. I ended up using a couple guitar picks and some old SIM cards to release one of the 12 tabs holding the front face plate in its casing. This avoided damaging the aluminum back that holds onto the faceplate. Be extra careful if you are attempting this, as it can require a lot of force, and you may require something sharp to release the tabs. With a lot of elbow grease and prayer, I was able to dislodge the faceplate from the aluminum backplate without any damage.

As soon as the faceplate was removed, I noticed a major issue. The headphone jack was disconnected from the main board, and the wire itself was missing entirely. What happened to it, I will never know, likely only 14 year old me knows the answer to that mystery. Since my iPod 4G was a A1059 model, I would need to find a 632-0260 cable for my headphone jack. I used a multimeter to verify the battery was functional, and also tested the other iPod components. After reseating the cable that connected to the display, I was able to get a picture, showing the device was charging. A small victory, but still I would not be able to use the clickwheel or headphone jack without further diagnostics, and while the battery was functional it was not holding a charge.

After surfing the web for a while, I came across a great resource called Elite Obsolete Electronics, where iPod 4G replacement parts are readily available for purchase. The headphone jack has three options to choose from, I went with the Flex Cable Only option, since my headphone jack appeared to be okay. Additionally I added a 1300mah Li-ion replacement battery to my cart, since it would be nice to actually be able to use the device once repaired.

Repair#

Once the cable and battery arrived I began surgery. Installing the flex cable was pretty simple, just take it out of the static bag it came in, and slide it in to the port on the left side looking into the internals of the iPod. If you are repairing the entire headphone jack, you need to remove the 3 screws holding the entire electronic to the top of the aluminum backplate instead.

Installing a new battery is more difficult however. As the wires are snaked underneath the motherboard, and the battery itself is adhered with a strong glue to the faceplate on top of the clickwheel.

First I removed the 20 GB hard drive.

This gave me access to the rest of the motherboard, and I went ahead and disconnected the battery. Be careful when doing this, as the battery cables are not that strong, I recommend using something thin, or even small needle nose pliers to lift straight up and away from the board. I also removed the display connector (ended up having to replace the clasp on this connector, as it was partially damaged) and clickwheel connectors on the left hand side of the motherboard.

After those connections were removed, I was able to pull out the entire motherboard and set it aside.

This left me with nothing but a faceplate, a screen, and the original battery adhered to the clickwheel.

Removing the original battery isn’t too difficult, but the glue is strong. If you have trouble you may need something sharp. However with some patience, you can gently pry the battery away from the clickwheel. Be careful not to damage the faceplate in the process. I also went ahead and removed the screen, so I could clean the protective transparent layer with some rubbing alcohol.

The new battery I purchased is slightly larger at 1300 mAh, and is a perfect fit for the old one. In the future, I may upgrade to an even larger battery, but for now I just wanted to see if I could get the device booting.

After having installed the new battery and the headphone jack flex cable, the device spun up and booted for the first time in over a decade. I then set out on backing up my music to my Hackintosh, and beginning some new research while I waited. I knew that the largest point of failure in this was the 20 year old hard drive that has a spinning disk inside of it, and should have died a long time ago. Not to mention 20 GBs of space in 2022 would just not cut it. So I set out to learn what options I had for replacing it with better storage, that wouldn’t fail on me any time soon.

Upgrade#

Having surfed the depths of the web, I came across a cheap but effective solution that used a Compact Flash to IDE 50-Pin Adapter. The Toshiba 20 GB hard drive was using a 50-Pin interface, so the adapter would be perfect for communicating with flash memory. Additionally I found a Compact Flash to dual MicroSD card adapter, that could work alongside the 50-Pin Adapter. I already had two 256 GB MicroSD cards on hand, so all I had to do was wait for these adapters to arrive, and then give them a try. Finding a place to purchase these adapters can be difficult, as you can imagine, these aren’t commonly purchased products. The CF adapter may be more readily available, since it has usages outside of the iPod. If you are looking for the same ones, I recommend searching Amazon and AliExpress as I found several versions of the adapters I ended up purchasing on those sites. While the adapters were shipping, I wiped and reformatted the two MicroSD cards as Fat32. Then I waited patiently for the adapters to arrive in the mail.

With the adapters finally on hand, I began replacing the hard drive with a flash storage solution.

I started by inserting the two 256 GB MicroSD cards into the Compact Flash adapter.

Then I attached the Compact Flash adapter to the 50-Pin Adapter.

If you look at the text written on the PCB of the 50-Pin Adapter, you’ll notice that it has a little arrow pointing at PIN 1, and says “Notice this before use!”. This is very important, as this is the most left PIN we want to use when installing this in the iPod. The adapter also came with a jumper, but fortunately mine was already configured how I needed it. Installing this monstrosity into the iPod wasn’t the easiest, as it doesn’t fit perfectly, the hard drive has a little hole that a tab enters to add some strength between the original flex cable and drive. This tab gets in the way of the adapters. You can shave this down with an X-Acto knife, or just force it, it’s entirely up to you.

Later I would add some protective layer such as foam padding between the adapters and the motherboard for extra care, and to prevent potential rattling while the device was in motion. With everything installed, I could factory reset it and give it a boot.

If you have an old iPod of your own, and would like to use a less hacky approach, instead of so many adapters, iFlash has a great product here, that supports up to four MicroSD cards simultaneously. The adapters will certainly be cheaper, but they are a less robust solution than what iFlash has to offer. While it’s likely possible to get a terabyte running with this method, it’s questionable whether the iPods software will support it, instead you may find that Rockbox is the only way to utilize flash storage sizes of that caliber. Keep in mind, if you do go this route, and you have a 4th generation iPod like me, you will need this adapter.

Software#

Surprisingly, Apple Music (RIP iTunes) actually works out of the box with this device. Finder even has a built-in integration for syncing with iPods, and it works similarly to what you would expect when you plugin in an iPad or iPhone. The actual process of managing or syncing songs or playlists with the iPod hasn’t really changed at all. So it’s full of quirks, and unless you have a lot of Apple owned music, you may want to try a different approach.

For my needs, Apple Music worked just fine however. I was able to reset the iPod to factory settings, and then begin restoring my old music. I was pleasantly surprised by how quick it had backed up my old 20 GB drive, and now restoring was even faster. Back when the iPod was released, I recall it taking hours to sync. I am curious what changed that made the backup take only 15 minutes today. The restore was ludicrously quick, but I imagine that had something to do with using flash memory instead of a spinning disk drive.

If I didn’t get Apple Music working, I would have setup Rockbox, an alternative firmware for the iPod, instead. This way I could manage all the music and content on the iPod, like a flashdrive. One of the cool features of Rockbox is that it has themes, even for the greyscale iPod 4G display. This theme in particular I found to be pretty intriguing. I may experiment in the future with Rockbox, but for now I am happy using the OG firmware.

Now that all my original music was restored, and I had a lot of extra space, I looked into migrating music off of Apple Music and Spotify. I found an incredible command line tool for spotify called spotdl. This allowed me to easily download music I have on my Spotify account by identifying the music and downloading it from alternative sources. If you want to keep your playlists, you’ll have to do that by hand, as transferring playlists from Spotify to Apple Music is not trivial. Some paid services do exist, but it wasn’t worth the effort in my opinion. Once I had downloaded all the music I wanted, it was as simple as dragging and dropping the files into the Automatically Add to Music directory in my users /Music/iTunes/iTunes Media/ directory. After a short sync, everything was loaded on my iPod and ready to go.

What’s next?#

This project was enjoyable to work on, as it allowed me to rediscover a lot of music that I had otherwise forgotten about. It is not every day I can open up a box of electronics from my childhood, and restore them to a healthy state. Sustainability is something I truly care about, so keeping my old electronics out of a landfill is important to me. I also learned a lot about the inner workings of an iPod, something I haven’t thought about in over a decade. In the future, I may write more on this if I get the itch. Perhaps I will expand the battery capacity even further, replace the faceplate with a new look, or attempt to restore a broken iPod 5 with video support. For now I will just be listening to some beach boys while I program.

Hardware Transcoding

Sat, 19 Dec 2020 05:38:00 GMT

This holiday season I had some down time. I was watching a home video on Plex when I noticed some artifacting on my Samsung TV. While this can be easily solved by transcoding all of my media to the lowest common denominator client device, it would require a lot of processing power and time to go through the entire content library. Additionally, without knowing which devices my family members all use, I would have no way of creating a reliable experience for them. For my own needs, changing to a client device that supports the media I was playing is the most straightforward solution. For those who are sharing their Plex with family and friends, you will want to look closer at your hardware.

Research#

I began researching why this was happening to my headless Ubuntu server. Starting with the hardware, I knew that out of the box, Plex will use your integrated graphics chip on the processor to handle any decoding or encoding, and will ultimately fallback to the CPU. The server in my basement today is currently running on fairly old hardware, the CPU is actually an i7-4790k. A quick search reveals an Intel specification here. This page explains that the CPU has the following Processor Graphics.

Processor Graphics ‡ Intel® HD Graphics 4600
Graphics Base Frequency 350 MHz
Graphics Max Dynamic Frequency 1.25 GHz
Graphics Video Max Memory 2 GB
Graphics Output eDP/DP/HDMI/DVI/VGA
Execution Units 20
Max Resolution (HDMI)‡ 3840x2160@24Hz
Max Resolution (DP)‡ 3840x2160@60Hz
Max Resolution (eDP - Integrated Flat Panel)‡ 3840x2160@60Hz
Max Resolution (VGA)‡ 1920x1200@60Hz
DirectX* Support 11.2/12
OpenGL* Support 4.3
Intel® Quick Sync Video Yes
Intel® InTru™ 3D Technology Yes
Intel® Flexible Display Interface (Intel® FDI) Yes
Intel® Clear Video HD Technology Yes
# of Displays Supported ‡ 3
Device ID 0x412

While the Intel® HD Graphics 4600 is very capable for it’s time, it isn’t as powerful as more modern integrated graphics. Using Intel’s integrated graphics worked well for years, and I highly recommend using it if your server has a newer chipset, such as a UHD 630. However, in my case, upgrading my entire 1150 LGA system was not within budget. So I looked at alternative solutions, such as a dedicated GPU.

Purchase#

Knowing that I wanted a dedicated GPU over an integrated one, I made a list of requirements comparing various GPUs on sale. Mainly something that was not too expensive (under $150), energy-efficient, and somewhat future-proof. Fortunately a Plex Hardware Transcoding chart was built that makes considering which GPU to get a breeze. I made note of the Quadro P3000 (6GB), GeForce GTX 1060 (6GB), Geforce GTX 1660 (6GB), and GeForce GTX 1660 Ti (6GB) options.

Looking at the chart above, these GPUs can support upto twenty simultaneous transcode streams. While all the GeForce GTX GPUs are limited to three simultaneous transcodes, a driver patch can be applied on Windows and Linux to remove this unnecessary limitation. Once the limitation is removed, the devices are capable of a theoretically unlimited number of transcode sessions. The next likely bottleneck for the GPU to run into is VRAM, and the options I chose above, all have 6GBs memory (while the Intel® HD Graphics 4600 had a measly 2GB). Of course, if you just go with a Quadro GPU instead, you don’t have to deal with this headache. However, Quadro GPUs tend to be more expensive, which makes them a less desirable option in this scenario, but they are certainly the easier choice.

And so my hunt for a GPU began. I shopped around, and found some decent deals, but nothing was as good as what I saw on eBay, OfferUp, Mercari, and Craigslist. After being outbid on a couple GeForce GTX 1660 (6GB), I ended up snagging an MSI Aero GeForce GTX 1060 (6 GB) in an ITX Form Factor on Mercari for $100. The GPU arrived in the mail in 5 days, and was in really great condition.

Installation#

Installing the GeForce GTX 1660 inside of my server was easy. I shut down the computer safely, and unplugged all of my peripheral devices. Removed the metallic door on the server, and took a peek inside. Despite the machines age, it is in pretty good condition, at least when ignoring the hideous cable management.

After grabbing a 6-Pin PCI-E cable for the power supply and plugging in the graphics card, I was ready to turn the machine on. Expecting everything to go off without a hitch, I was sorely disappointed when video was no longer being displayed. Neither via the new GPU or the old. It seemed pretty clear to me that the computer was not POSTing. I knew that my 750 Watt PSU was capable of supplying enough power to support this 120 Watt (Max) Graphics Card, so I knew to look elsewhere.

Removing the Graphics Card alleviated the issue, but of course that is not the goal. I reexamined the setup and found the culprit to be the motherboards Voltage Protection. After changing the outlet that my server is plugged into in the APC Battery Backup, everything started working as expected. I suspected this was the issue, due to the fact that when plugged directly into a wall outlet, the computer booted. The Battery Backup only has around a 8% load, so it is certainly not drawing too much from it. If I had to guess, I’d say the older ASUS chipset on my motherboard likely has some protections in place that are misfiring. If anyone is more familiar with battery backups, I’d be interested to hear your thoughts on why this happens. I am just glad it was such an easy fix.

Nvidia Drivers#

Before running the nvidia-patch to remove the limitation on the GeForce GTX 1060 I needed to install the approriate nvidia drivers. While you can follow the instructions as described in the Github README of nvidia-patch, you can also do this using your OS’ package manager.

I started by running the following command, which recommended a driver for my graphics card. Below you can see the recommended driver is nvidia-driver-455. This happened to be the same one nvidia-patch recommended, so if you have a different list, keep an eye out that the driver is compatible with the patch you are applying.

$ sudo ubuntu-drivers devices
== /sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0 ==
modalias : pci:v000010DEd00001C03sv00001462sd00003283bc03sc00i00
vendor   : NVIDIA Corporation
model    : GP106 [GeForce GTX 1060 6GB]
driver   : nvidia-driver-390 - distro non-free
driver   : nvidia-driver-450 - distro non-free
driver   : nvidia-driver-450-server - distro non-free
driver   : nvidia-driver-455 - distro non-free recommended
driver   : nvidia-driver-418-server - distro non-free
driver   : nvidia-driver-440-server - distro non-free
driver   : xserver-xorg-video-nouveau - distro free builtin

Next I installed the recommended driver for my graphics card and rebooted.

$ sudo apt install nvidia-driver-455
$ sudo reboot

I checked that the driver was installed successfully after rebooting by running nvidia-smi. Normally this would work as expected. Unfortunately my server BIOS had been configured to enable Secure Boot. On many modern motherboards you can just run the following command to import the secure key so that the OS will allow the driver to run.

$ sudo mokutil --import /var/lib/shim-signed/mok/MOK.der

After rebooting, the driver was not available, and mokutil failed with every command, including when using the --import argument. After a bit of digging, I learned that on some motherboards, you can enroll keys in the BIOS SecureBoot setup. After installing the nvidia driver via apt, you’ll find the necessary key blob data in /var/lib/shim-signed/mok named MOK.der. This file is unique to my computer, and future driver installs will be signed with the same key.

I copied the MOK.der to a USB, and then rebooted into the BIOS. For my BIOS, I enabled Advanced Mode and then navigated to Boot/SecureBoot/KeyManagement. Here I found a lot of different options, but the one I needed was called Append to Default DB. A prompt appeared when selecting this option, choosing No allowed me to select a file from the USB. After selecting the MOK.der from the USB, a prompt popped up asking what type of data the file contains. I chose Blob Data and then saved (pressed F10) and rebooted.

Once the computer restarted, I ran nvidia-smi. Finally the driver was installed and running.

$ nvidia-smi
Sat Dec 19 17:38:11 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 455.38       Driver Version: 455.38       CUDA Version: 11.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  GeForce GTX 106...  Off  | 00000000:01:00.0  On |                  N/A |
|  0%   33C    P8     4W / 120W |      4MiB /  6075MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

Plex and Docker#

Now that the driver was functioning properly, and the graphics device appeared under /dev/dri I could configure Plex to use it. Currently, I run Plex within a container using Docker. To use a nvidia GPU with docker I had to follow the Nvidia docker documentation here. So I ran the following command, as described in the documentation.

$ sudo apt update && apt install -y nvidia-docker2

Since I use docker-compose, I assumed I would need to update the docker-compose.yml file where the plex service is defined. Although the devices don’t need to change because I previously configured Intel Quick Sync transcoding, it is important that we set the appropriate environment variables. For us to get full hardware transcoding functioning correctly, we must set NVIDIA_VISIBLE_DEVICES=all and NVIDIA_DRIVER_CAPABILITIES=compute,video,utility. This will allow all of our Nvidia graphics devices and the associated libraries to be accessible from within the docker container. See my updated docker-compose.yml below which includes both environment variables.

version: '3.7'
services:
  plex:
    image: plexinc/pms-docker:latest
    restart: unless-stopped
    environment:
      - PLEX_UID=0
      - PLEX_GID=0
      - TZ=${TZ}
      - CHANGE_CONFIG_DIR_OWNERSHIP=true
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,video,utility
    ports:
      - 32400:32400/tcp
      - 3005:3005/tcp
      - 8324:8324/tcp
      - 32469:32469/tcp
      - 1900:1900/udp
      - 32410:32410/udp
      - 32412:32412/udp
      - 32413:32413/udp
      - 32414:32414/udp
    devices:
      - /dev/dri:/dev/dri
    volumes:
      - ${CONFIG_ROOT}/config/plex/db:/config
      - ${CONFIG_ROOT}/config/plex/transcode:/transcode

I use version 3.7 of docker-compose, so unfortunately configuring the nvidia runtime is a bit more indirect. If you use the version 2 configuration of docker-compose you can just add runtime: nvidia to the docker-compose.yml instead. But for 3.7 I needed to update the /etc/docker/daemon.json with the following.

{
  "default-runtime": "nvidia",
  "runtimes": {
    "nvidia": {
      "path": "nvidia-container-runtime",
      "runtimeArgs": []
    }
  }
}

Now that I have docker configured to use the nvidia runtime, I need to restart the docker service. This can be easily done on Ubuntu server by executing the following command.

$ sudo service docker restart

Then I restarted the services that manage my container orchestration.

$ sudo service theater restart

I verified that the correct libraries were made available to the container using the following command.

$ docker exec -it plex ldconfig -p | grep -i nvidia
  libnvidia-ptxjitcompiler.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-ptxjitcompiler.so.1
  libnvidia-opticalflow.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-opticalflow.so.1
  libnvidia-opencl.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
  libnvidia-ml.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-ml.so.1
  libnvidia-encode.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-encode.so.1
  libnvidia-compiler.so.455.38 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-compiler.so.455.38
  libnvidia-cfg.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-cfg.so.1
  libnvidia-allocator.so.1 (libc6,x86-64) => /usr/lib/x86_64-linux-gnu/libnvidia-allocator.so.1

Then verified nvidia-smi functions as expected.

$ docker exec -it plex nvidia-smi

I saw the same output as before when running nvidia-smi so I knew the container had access to the graphics device. Now we just need to make sure plex is able to transcode media. I played the video that was originally producing artifacts on my TV. On another device, I opened a browser, navigated to my plex server, and then went from Settings to Manage / Console. Here I could filter the Console logs however I wanted.

For those adverse to using the Plex dashboard, you can easily do this on the server like so.

$ tail -f plex/db/Library/Application\ Support/Plex\ Media\ Server/Logs/Plex\ Media\ Server.log | grep "TPU:"

If I filter by TPU: or MDE: I can see what device is being used for transcoding and why transcoding is happening. Below is a helpful list of terms I found that can be used for debugging.

MDE:
TPU:
ffmpeg
codec
decoder
encoder
hardware

The output shows the following when filtered by TPU:.

Dec 19, 2020 13:36:34.912 [0x7fea797fa700] DEBUG - [Transcode] TPU: hardware transcoding: using hardware decode accelerator nvdec
Dec 19, 2020 13:36:34.912 [0x7fea797fa700] DEBUG - [Transcode] TPU: hardware transcoding: zero-copy support present
Dec 19, 2020 13:36:34.912 [0x7fea797fa700] DEBUG - [Transcode] TPU: hardware transcoding: using zero-copy transcoding
Dec 19, 2020 13:36:34.912 [0x7fea797fa700] DEBUG - [Transcode] TPU: hardware transcoding: final decoder: nvdec, final encoder: nvenc

Analyzing these logs, I saw that both nvdec (Nvidia Decoding) and nvenc (Nvidia Encoding) were being used when hardware transcoding. While Plex was busy, I also ran watch -n 0.5 nvidia-smi in a separate tmux session. This made it easy to monitor the GPU temperature, usage, and power draw. Fortunately, while idle the GPU stays around 35° Celsius and draws ~4 Watts. During load on two streams I saw the temperatures rise 13° to 48° Celsius and wattage increase to ~35 Watts. While the GPU has its own limitations, Plex will fallback to the CPU if it can’t use the GPU for some reason, such as an unsupported format or the GPU being too busy. However, it is not capable of load balancing between multiple GPUs such as multiple GeForce GTX 1060s or the Intel® HD Graphics 4600 coprocessor.

Was it all worth it?#

I can now watch videos without weird artifacts appearing on my TV, and my family and friends can do so without having to worry so much about which device they are using. If you are interested in reading more about hardware accelerated streaming with Plex, they have a great article on the subject here. While this was an afforable and fun upgrade for my server, your system will likely have different needs and requirements. If you are building from scratch, the easiest path will certainly be to get an Intel processor that has powerful integrated graphics. The newer (2021) Rocket Lake processors for example will support hardware decoding for HEVC 12-bit, 4:2:2/4:4:4; VP9 12-bit 4:4:4 and AV1 8K 10-bit 4:2:0. When considering building a Plex Server of your own, I recommend reusing what you can. Many users of Plex have it running on nothing but a Raspberry PI, but for those users, you can be sure they are mostly utilizing direct play over transcoding.

Hackintosh

Fri, 30 Aug 2019 04:03:00 GMT

About a year ago I had the wonderful opportunity to put together a computer at work. Originally I had been considering a Macbook Pro, however the 2018 models still have terrible keyboard issues and Apple has done a bad job of taking the issue seriously. If you ask anyone who knows me they will tell you how seriously I take quality keyboards. Which is why I get really weird looks whenever anybody sees my Ergodox keyboard. The market for alternative laptops was also not getting my hopes up. Plus I would have to ditch macOS if I went that route which I have come to enjoy using more and more over the years. I could have tried to hackintosh a laptop, but did not care for restrictions and bugs. Ultimately I decided I would use my 2015 Macbook Pro as my daily note taker and for everything else (development) I’d use a desktop.

The desktop needed to be powerful, and also compatible with components that would run macOS Mojave with relative ease. Additionally I had some 2.5” SSDs and an M.2 lying on my desk. This let me plan a multiple OS system, so I could boot Windows 10 and Ubuntu 18.04 in addition to macOS. This was especially convenient as the development I do is cross platform. I planned four different builds on PC Part Picker and considered my options for over a month. After grueling analysis and waiting for the right price drops I executed the purchase for all of the components.

What you might imagine Christmas at Bill Gates’ house looks like

Processor#

At the time the Ryzen 9 had not yet been released, and wouldn’t be released for another six months. But even if it was out, Intel CPUs are generally easier to work with in hackintosh builds, as they work out of the box. I took a look at Intel CPUs that came out recently, and fortunately the i9-9900K had been released while I was doing my research. This CPU was affordable and would get me the performance I was looking for. With 8 Cores and 16 threads I would get to spend significantly less time compiling my Elixir applications. The other processor I considered was the i7-8700K, it is a really decent choice, but ultimately I wanted that extra push from the i9. You can see a benchmark comparison here of these three processors. While idle the liquid cooled CPU can dip below 30° C and full load across all cores (Video Transcoding) gets it to about 59° C.

Pretentious Intel packaging

Motherboard#

With the idea that I was going to use an Intel based processor, I started looking at what motherboards could work well in a Hackintosh today. InsanelyMac has some great resources I took advantage for this. The consensus was that the Intel Z370 chipset motherboards were working great across the board, but they wouldn’t be able to drive my i9. The next chipset was the Z390, but a lot less success stories were told with this motherboard at the time. Even today the Z390 motherboard doesn’t have NVRAM support, so if that is something you really want/need I would avoid it. However, for my purposes NVRAM could be emulated, and so I decided on the Asus ROG Strix Z390-i motherboard. It has the small form factor I want and supports two M.2 SSDs. Additionally this motherboard had onboard WiFi and Bluetooth, but the built-in Intel chip would not work out of box, so I would have to come up with another plan if I wanted a WLAN.

Motherboard arrival and unboxing

Storage & Memory#

These components were the easiest to choose. Getting a good NVME drive is not a difficult task, and memory prices have been steadily decreasing. 2019 has been a good year to buy storage and memory in my opinion. Unfortunately I bought all these components right on the cliff in 2018, but I wasn’t the one paying so it wasn’t a big deal to me. I had some spare drives on my desk I was planning on using so I went with some SSDs, a Samsung 1TB 970 Evo NVME SSD and 2x Corsair 16GB DDR4-3200 RAM. In total the computer has around 2 TBs of SSDs, and 32 GB of RAM.

Spare solid state drives

Graphics Processor#

Originally I planned to use a Radeon Vega 64 in this build, and I tried. But the GPU was behaving oddly (later I would find out this was due to the Phanteks PCI-E Extension cable). Additionally the case I got was tight, and has pretty awful ventilation. My temperatures aren’t horrendous, but I think the GPU definitely suffers in this case more than is necessary. If you are considering a dedicated GPU for a build in this case I recommend getting a blower style model, as those will fair much better with this layout. Ultimately I ended up going with a Sapphire Pulse Radeon RX 580. This GPU is highly compatible with macOS and is not very expensive at the moment. Despite having the standard fan layout, my temperatures are around 33° C idle and 45° C for a medium load. Stress tests can get the GPU up to 70° C, but those do not represent normal usage at all for a dev machine.

Sapphire RX 580 fitting nicely in the Phanteks Evolv Shift case

WiFi & Bluetooth#

The Z390i motherboard came with onboard WiFi and Bluetooth, even boasting AC and Bluetooth 5.0 support. Unfortunately this chip does not work with macOS at this time, and may never. So instead of waiting I went searching for an equivalent WiFi/Bluetooth module that I could swap with the one hidden below the motherboards heatsinks. The Broadcom BCM94352Z was the perfect fit, I recommend the Lenovo or Dell DW1560 models as they can be found for a little cheaper. Taking the motherboard apart and then the wireless casing was definitely not for the faint of heart, if you haven’t modified a motherboard before, I would probably avoid it and pay someone else to do it.

Disassembled motherboard prior to WLAN replacement

After replacing the onboard chip, WiFi and Bluetooth worked great. macOS required some Broadcom kexts (AirportBrcmFixup and BrcmBluetoothInjector) for use if you decide to go this route, but it is not very difficult to get setup. This meant I could even use macOS features such as Continity, Handoff, and Apple Watch Unlocking on Mojave. Ubuntu and Windows also liked this chip, and required no additional drivers or setup on my part.

New WLAN fitting snug in our enclosure with antennae connected

Case & Cooling & Power#

I knew this build was going to be small, since I chose the ITX motherboard above. I came across the Phanteks Evolv Shift Mini ITX Tower case. It seemed perfect for my build, although some of the reviews warned about heating issues. I went with a Corsair H80i v2 liquid cooling block for the CPU to attempt to counteract the lack of fans that would fit inside. The temperatures remain fairly low, and I am pretty happy with the benchmarks I get from the machine. Unfortunately the biggest let down was the riser that came with this phanteks case. It is extremely low quality, and ultimately I ended up using a dremel to cut the riser mount so I could install a higher quality thermaltake one. This case is really gorgeous and small, but I probably would go with something else if I was to start from scratch. It was difficult to work in, and that riser gave me a huge headache, since of course I was blaming the GPU for any graphical issues I was experiencing at first. For power I did not find many options, especially in such a tight case. The Corsair SF 600W was high quality, and modular which is vital when working in a case like this. The H80i I received actually crapped out on me during the first week of tests. Fortunately the reseller worked with me to replace the broken part, and now the CPU is being cooled just fine.

Getting the machine setup in a new office space

Results#

This computer is a beast, it really is significantly better than any Macintosh I have used. The new Mac Pros are coming out, and the specs will surely beat this machine I have put together when they do. However, looking at my PC Part Picker List of components, as of writing the price is less than $1,500.00! It is difficult to find even a good Macbook for that price. The price to performance ratio here is pretty mind blowing, and I would highly recommend going this route instead of buying an overly priced Mac if you have the know-how.

System details after my first boot into mojave

Since you may have come across this looking for how to setup a similar build, here is a link to the EFI directory. I am using macOS 10.14.6 as of August 2019 with this EFI. If you have any questions about the setup or steps you need to take feel free to ask.

Last but not least, it can even run fortnite!

React Image Hook

Thu, 11 Jul 2019 05:57:00 GMT

A frequent problem I run into in web development is image loading. The web has built-ins for this, such as <img /> and <picture />. They are not that powerful or flexible however. What if you need fallbacks, or want to do something fancy with low quality image placeholders then you may need something better. Image loading in JS also needs to have a flexible API that happens to work across any browser, lets say IE10 and up, as well as the last 2 versions of Firefox, Chrome, Edge, et cetera. This comes with a lot of trade offs, and you can feel like you are walking on egg shells at times. It would be nice if we could use the modern Promise API instead of the old onload and onerror callbacks we are used to. By the end of this short read, you should feel like you can load images for any use case, and even better with React Hooks!

So lets start by creating a module loadImage.js.

export default (url) => new Promise();

Next we are going to want to create an image that can tell the browser we want to download an image. This is done by setting the src property of the image to a particular url. In some cases this might be across origins, so lets add an option for that as well.

export default (url, crossOrigin) => {
  const image = new Image();

  if (crossOrigin) image.crossOrigin = crossOrigin;

  return new Promise(() => {
    image.src = url;
  });
};

We haven’t implemented our promise API properly yet however. We need to fulfill our promise when the image loads, and handle it failing as well. This can be done with addEventListener or the older on event callbacks, such as onload, onerror, or onabort. Let’s try using them below.

export default (url, crossOrigin) => {
  const image = new Image();

  if (crossOrigin) image.crossOrigin = crossOrigin;

  return new Promise((resolve, reject) => {
    const loaded = (event) => {
      resolve(event.target);
    };

    const errored = (error) => {
      reject(error);
    };

    image.onload = loaded;
    image.onerror = errored;
    image.onabort = errored;

    image.src = url;
  });
};

Nice now we can finally give it a try and see if that worked.

import loadImage from './loadImage.js';

async function getImage(url) {
  try {
    const img = await loadImage(url, false);
    // Use `img` however we want, cache it or measure it
    console.log(img.src, img.height, img.width);
  } catch (err) {
    // report error, load fallback, retry, et cetera
    console.error(err);
  }
}

getImage('https://vincenttaverna.com/media/image-1.jpg');

Great it works, but with one caveat. Our callbacks are never being cleaned up. We never called removeEventListener or more specifically in this case we forgot to unbind our events. Nothing to fret over, we can easily do so by adding an unbindEvents method.

export default (url, crossOrigin) => {
  const image = new Image();

  if (crossOrigin) image.crossOrigin = crossOrigin;

  return new Promise((resolve, reject) => {
    const loaded = (event) => {
      unbindEvents(image);
      resolve(event.target);
    };

    const errored = (error) => {
      unbindEvents(image);
      reject(error);
    };

    image.onload = loaded;
    image.onerror = errored;
    image.onabort = errored;

    image.src = url;
  });
};

function unbindEvents(image) {
  image.onload = null;
  image.onerror = null;
  image.onabort = null;
}

To get older browser support you will need to polyfill the Promise API. You may also need to use e.target || e.srcElement instead to get older IE to cooperate, but otherwise this should work across many different browsers and OS’. Below you can find the complete example with these macro modifications.

export default (url, crossOrigin) => {
  const image = new Image();

  // Support cross origin requests
  if (crossOrigin) image.crossOrigin = crossOrigin;

  return new Promise((resolve, reject) => {
    // Load Handler
    const loaded = (event) => {
      // Cleanup our image element, we no longer need it
      unbindEvents(image);
      // Fulfill our promise with the event image element, even in older browsers
      resolve(event.target || event.srcElement);
    };

    // Error Handler
    const errored = (error) => {
      // Cleanup our image element, we no longer need it
      unbindEvents(image);
      // Forward our error to the user
      reject(error);
    };

    // Set our handlers
    image.onload = loaded;
    image.onerror = errored;
    image.onabort = errored;

    // Tell the browser we are ready to begin downloading
    image.src = url;
  });
};

function unbindEvents(image) {
  // Reset callbacks
  image.onload = null;
  image.onerror = null;
  image.onabort = null;

  try {
    // Some browsers need you to remove the src
    // in order to garbage collect the image object
    delete image.src;
  } catch (e) {
    // Safari's strict mode throws, ignore
  }
}

Okay, well now we have a useful helper for loading images, but what else can we do with this? I mean I don’t even know how to use this with my cool new React SPA 😡. What if we were to instead wrap this in a React Hook so we could use it across an existing application 😁? Let’s create a hook called useImage and see if we can use this new helper effectively.

import loadImage from './loadImage.js';

export default function useImage(src) {}

We are going to need to keep track of the state (useState) of the image as it is loading. This will allow users of our useImage hook to know whether or not the image has loaded. We will add states for loading, loaded, and failed. Additionally we are going to need to know when the component is updated, so we will need to useEffect.

import { useState, useEffect } from 'react'
import loadImage from './loadImage.js'

const Status = {
  LOADING: 'loading',
  LOADED: 'loaded',
  FAILED: 'failed',
}

export default function useImage(src) {
  const [status, setStatus] = useState(initialState)

  useEffect(() => {
    if (!src || status === Status.LOADED) return

    try {
      const image = await loadImage(src)
      setStatus(Status.LOADED)
    } catch (error) {
      setStatus(Status.FAILED)
    }
  }, [src])

  return [status]
}

This is starting to look like an actual hook. We could do better though. Let’s add a cache to reuse image objects. This will make future attempts to load a particular cached src avoid loading entirely.

Additionally we should make sure we call useRef to keep track of whether or not we are mounted. This is necessary so we do not try to load images when the component is no longer mounted.

import { useState, useEffect, useRef } from 'react'

import loadImage from './loadImage.js'

const cache = new Map()

export const Status = {
  LOADING: 'loading',
  LOADED: 'loaded',
  FAILED: 'failed',
}

export default function useImage(src) {
  const cachedImg = cache.get(src)
  const initialState = cachedImg ? Status.LOADED : Status.LOADING
  const [status, setStatus] = useState(initialState)
  const mounted = useRef(false)

  useEffect(
    () => {
      if (!src || status === Status.LOADED) return
      mounted.current = true

      try {
        const image = await loadImage(src)
        if (!mounted.current) return

        cache.set(src, image)
        setStatus(Status.LOADED)
      } catch (error) {
        if (!mounted.current) return

        cache.delete(src)
        setStatus(Status.FAILED)
      }
      return () => {
        mounted.current = false
      }
    },
    [src, status]
  )

  return [status, cachedImg]
}

Notice I used a Map here for the cache. If you are using older browsers and are not transpiling your code using something like babel I recommend using a simple object instead.

Let’s see how we might use useImage in the wild.

import React from 'react';
import useImage, { Status } from './useImage.js';

import fallback from './fallback.png';

export default function Image({ src }) {
  const [status, image] = useImage(src);

  if (status === Status.LOADING) {
    return <div className="spinner" />;
  }

  let source;
  if (status === Status.FAILED) {
    source = fallback;
  } else {
    source = src;
  }

  return <img src={source} />;
}

Great! This is a super flexible API to work with, and can easily be extended to do numerous things. Such as LQIP, lazy loading, or anything we may need. If you wanted you could add onLoad and onError callbacks to this hook, but ideally you can do everything you want in render now that you have the status.

As an exercise try adding IntersectionObserver to this hook. Make it only download a given image until the image is actually on screen. Go a step further and display a placeholder until the image is on screen. You will end up with a really convenient way to handle lazy loading, and prevent your browser from downloading images unnecessarily. This can save a lot of bandwidth for your users, as well as make your page load much faster!

If you made a powerful image loader, found this instructional interesting, or just want to ask me something, feel free to bring it up in the comments below.

Thanks for reading

Programming Phoenix

Sat, 23 Jun 2018 08:38:00 GMT

Some quotes from Programming Phoenix that inspire

In July 2015, we (Chris McCord) compared Phoenix with Ruby on Rails. The firebird was nearly an order of magnitude faster than the locomotive, and it used just over one fourth of the processing power and just under one sixth of the total memory. Those numbers are staggering, but not many Rails users are after naked power.

In Phoenix, you won’t have to read through dozens of skip_before_filter commands to know how your code works. You’ll just build a pipeline for each group of routes that work the same way.

One continuous problem with web frameworks is that they tend to bloat over time, sometimes fatally. If the underlying abstractions for extending the framework are wrong, each new feature will increase complexity until the framework collapses under its own weight. Sometimes, the problem is that the web framework doesn’t include enough, and the abstractions for extending the framework aren’t right. This problem is particularly acute with object-oriented languages. Inheritance is simply not a rich enough abstraction to represent the entire ecosystem of a web platform. Inheritance works best when a single feature extends a framework across a single dimension. Unfortunately, many ambitious features span several different dimensions.

As a developer, until now, you’ve been forced to make a choice between applications that intentionally forget important details to scale and applications that try to remember too much and break under load.

Phoenix has: isolation and concurrency. Isolation guarantees that if a bug affects one channel, all other channels continue running. Breaking one feature won’t bleed into other site functionality. Concurrency means one channel can never block another one, whether code is waiting on the database or crunching data. This key advantage means that the UI never becomes unresponsive because the user started a heavy action.

The problem for Rails developers is that the scope of problems it’s best able to solve is rapidly narrowing.

If you’re a Java developer looking for where to go next, or a JVM-language developer looking for a better concurrency story, Phoenix would mean leaving the JVM behind. Maybe that’s a good thing. You’ll find a unified, integrated story in Phoenix with sound abstractions on top. You’ll see a syntax that provides Clojure-style metaprogramming on syntax that we think is richer and cleaner than Scala’s.

A web server is a natural problem for a functional language to solve.

In Phoenix, that connection is the whole universe of things we need to know about a user’s request.

We process data in the model; we read or write that data through the controller. Ecto allows us to organize our code in this way. It separates the code with side effects, which changes the world around us, from the code that’s only transforming data.

the atom table isn’t garbage-collected.

Your application is a series of plugs, beginning with an endpoint and ending with a controller

mix ecto.gen.migration create_user

Coffee to Babel in 24 hours

Wed, 30 Nov 2016 09:17:00 GMT

Recently I was tasked with modernizing a CoffeeScript codebase to use Babel. I’ve used babel (and 6to5) across various projects for almost two years, not to mention I have been writing CoffeeScript since it has been in the hands of the public. I was told to convert the code to coffee to babel as quickly as I could. Fortunately the project I was working with was already setup with webpack which made using the babel-loader alongside the coffee-loader a possibility if I failed to convert everything on time. With that in mind I configured a basic .eslintrc and .babelrc and started the process of translation.

Surprisingly the process didn’t start with actual translations. Manual translation would not be quick enough. Dredging through hundreds of coffee files was going to take me way more time than I had. So I started searching around for tools that could convert CoffeeScript to Babel. Tons of tools exist, but nothing to do this exact conversion. Luckily you can get something working pretty well if you use the right combination of tools. You will come across some files that don’t fully convert, and you may even need to tweak the conversion tool to get it working to your liking. Given a time crunch like I had, you would be glad to have this as an option.

CJSX-Codemod #

If you aren’t using JSX, or you don’t know what JSX is, you can ignore this tool. It is only required if you were previously using JSX, and you can move on to the next tool I used in this process. For everyone else, this tool lets us convert JSX to coffee. So lines like <div /> will translate to React.createElement('div', null). You can globally install this package and then run it over a directory of scripts of your choosing. It will fire off some workers and tell you if it had any trouble along the way. If you are lucky everything will go smoothly. I recommend sanity checking throughout each step, and committing the changes that you are making so you don’t end up wasting any time.

yarn global add cjsx-codemod
cjsx-codemod ./scripts

Decaffeinate #

This next tool will convert a coffee file to a babel compatible file. I couldn’t find a great way to run the tool over a directory of scripts. Fortunately you can just run the command on a list of coffee files by piping it through xargs. If you don’t know what the command below does let me explain. I search for files in a folder of my choice and then filter by coffee files. Next I run the decaffeinate command on each file that has been found. You should end up with a bunch of new javascript files, and your existing coffee files should remain untouched. Feel free to delete the coffee files now that they are unnecessary.

yarn global add decaffeinate
find ./scripts | grep .coffee | xargs -n 1 -P 5 decaffeinate

React-Codemod #

Again, you should be able to ignore this if you aren’t using JSX. This tool lets us turn those React.createElement calls back into JSX. You will need to add jscodeshift first, as this is just a script we tell it to use on a directory of javascript files. Make sure everything looks good, and move on to the final step.

yarn global add jscodeshift
git clone https://github.com/reactjs/react-codemod.git
cd ./react-codemod
yarn --no-lockfile
jscodeshift -t ./react-codemod/transforms/create-element-to-jsx.js ./scripts --no-explicit-require

ESLint #

I recommend configuring a .eslintrc. You can install ESLint and have it automatically fix up the transpiled code. This final step will give you a much more readable and clean result.

yarn add eslint --dev
./node_modules/eslint/bin/eslint.js --fix ./scripts

Others#

Below are some other tools that I found useful. You may find they give you false positives, so make sure to review all your changes carefully before committing. I hope these tools will help you out of a tight situation like the one I was in.

Blog Performance

Fri, 25 Nov 2016 02:06:00 GMT

Recently I revamped this blog site using the amazing GatsbyJS. I noticed immediately how much faster it was, and that was in part due to how much work has gone into making gatsby produce an optimized site. I recently watched a video by Sam Saccone and Paul Irish about performance and metrics. They spoke about two tools Lighthouse and PWMetrics which you can use today to measure your site performance in a useful way. I was able to quickly grasp what bottlenecks were having an adverse affect on the blogs load times.

Through diagnosis I was able to drastically improve the score. Here is what I get from pwmetrics today.

You can even generate it yourself. Just try out the commands below.

yarn global add pwmetrics
pwmetrics https://vincenttaverna.com

yarn global add lighthouse
lighthouse https://vincenttaverna.com

The next version of GatsbyJS, v1, is being developed right now. It will improve performance even more so, and I am really looking forward to it. Between inline CSS, offline support via service workers, and more, it will be the best release yet. If I find spare time I will definitely be contributing to it and I think you should to!

The Witcher

Tue, 22 Nov 2016 02:14:03 GMT

After having read most of The Witcher by Andrzej Sapkowski some words stood out more than others. Below are some of my favorites from the series. I will update this as I finish the rest of the books.

Gravamen
noun | gra·va·men | \grə-ˈvā-mən\: plural Gravamens or Gravamina; ¶ The material or significant part of a grievance or complaint
Riposte
noun | ri·poste | \ri-ˈpōst\: ¶ A quick and clever reply
Akimbo: ¶ Of the arms : with the hands on the hips and the elbows turned outward; ¶ Of the legs : spread apart in a bent position
Dentata: ¶ Latin for Toothed
Milliner: ¶ A person who designs, makes, trims, or sells women's hats

ECMAScript 6 - Harmony

Thu, 16 Jul 2015 00:00:00 GMT

18 Years of Specifications#

ECMAScript 1 through 5#

Precursor
- Brendan - Mocha
- Netscape codenames LiveScript
- Netscape announces JavaScript (1995)
- Netscape releases JavaScript (1996)
1 ECMA establishes specification (1997)
2 ISO/IEC 16262 I18N (1998)
3 RegExp, String formatting, try/catch, errors (1999)
4 failure, arguing, punted and renamed Harmony (1999-2009)
5 ‘use strict’, JSON, get, set, reflection (2009)
5.1 international standardization (2011)

Transpiling#

Firefox, Chrome hot on tail
GWT/Type/Clojure/Dart/Coffee/JSX history
Compiling to ES5
ES6 via Babel (71%) or Traceur (58%)
Mana began development with ES6 via Babel
ES6 gets standardized (June 2015)

Constants#

Immutable Variables

const e = 2.718281828459045;
const π = 3.141592653589793;
e < π; // → true
e = π; // → Line 4: "e" is read-only

Scoping#

Block-Scoped Variables

let a = [1];
for (let i = 0; i < a.length; i++) {
  let x = a[i] + 1;
}
console.log(i, x, a); // → i is not defined, x is not defined, [1]

Block-Scoped Functions

{
  function foo() {
    return 'hello';
  }
  foo(); // → hello
  {
    function foo() {
      return 'world';
    }
    foo(); // → world
  }
  foo(); // → hello
}

Arrow Functions#

Expression Bodies

let admins = collection.map((m) => m.get('admin'));
console.log(m); // → m is not defined

Statement Bodies
Lexical this

this.accepted = [];
this.collection.each((m) => {
  if (m.get('state') === 'accepted') this.accepted.push(m);
});

Extended Parameter#

Defaults
Rest Parameter

{
  initialize: function(options = {}) {
    _(this.defaults).extend(options);
  },
  generateName: function(conversation, names...) {
    console.log(names); // → ["Angie", "Ariel", "Jared"]
    conversation.set("name", names.join(", "));
  }
}

Spread Operator

var params = ['kana', [true], 7];
[1, 2, ...params].length; // → 5

Template Strings#

String Interpolation

var lastSeenAt = `Last Seen ${manawa(this.model.get('sent_at'))}`;

Multiline support

console.log(`Aloha
Hawaii`); // → Aloha Hawaii

Raw String Access

String.raw`Hi, \n World ${42}` === 'Hi, \\n World 42'; // → true

Extended Literals#

Binary and Octal

0b110010100 === 404; // → true

Unicode String/RegExp

'\u{0CA0}_\u{0CA0}' === 'ಠ_ಠ'; // → true

Enhanced Regular Expression#

Sticky Matching
Efficient Parsing

let regex = /foo.bar/gy;
regex.sticky; // → true
regex.lastIndex; // → 0

regex.test('foo-bar'); // → true

regex.lastIndex; // → 7
regex.test('..foo-bar'); // → false

regex.lastIndex = 2;
regex.test('..foo-bar'); // → true

regex.lastIndex; // → 9

Enhanced Object Properties#

Property Shorthand

var options = { animate, duration };

Computed Property Names
Method Properties

var properties = {
  color: 'blue',
  ['avatar_' + getSize()]: 42,
};

var helpers = {
  foo(a, b) {
    // …
  },
  *quux(x, y) {
    //  …
  },
};

Destructuring Assignment#

Array Matching

var list = ['Blue', 'Red', 'Yellow'];
var [first, , second] = list;
[second, first] = [first, second];

Object Matching (Deep)

var {
  members,
  meta: { total_count, updated_at },
} = payload();

Parameter Matching

function sum([x, y]) {
  return x + y;
}
function msgText({ name, body }) {
  return `${name}: ${body}`;
}

Fail-Soft with Defaults

var [a = 1, b = 2, c = 3, d] = [4, 5];

Modules#

Export

export function randomNumber {
  return Math.floor( Math.random() * 11 );
}

Import

import { Input, Label } from 'react-bootstrap';

Default

export default (x) => x * x;

Wildcard

import * as _ from 'underscore';

Classes#

Declaration / Inheritance
Expressions
Base Class Access
Static Members
Getters / Setters

class Group extends Party {
  constructor(name, color) {
    super(name);
    this.color = color;
  }
  static defaultGroup() {
    return new Group('Engineering', '#232b38');
  }
  set name(name) {
    this._name = name;
  }
  get name() {
    return this._name;
  }
  get color() {
    return this._color;
  }
}
var engineering = Group.defaultGroup();
engineering.color === '#232b38';

Symbol Type#

Unique
Immutable
Optional Descriptions (debug)

let attributes = {};
const avatar = Symbol();
attributes[avatar] = new Avatar();

typeof avatar; // → "symbol"
Object.getOwnPropertySymbols(attributes); // → [ avatar ]
Symbol('avatar') === Symbol('avatar'); // → false

Global Symbols

let globalAvatar = Symbol.for('avatar');

globalAvatar === Symbol.for('avatar'); // → true
Symbol.keyFor(globalAvatar); // → avatar

Iterators#

Iterable Protocol

let fibonacci = {
  [Symbol.iterator]() {
    let pre = 0,
      cur = 1;
    return {
      next() {
        [pre, cur] = [cur, pre + cur];
        return { done: false, value: cur };
      },
    };
  },
};

For _ of _

for (let n of fibonacci) {
  if (n > 1000) break;
  console.log(n);
}

Generators#

Iterator Protocol
Direct
Matching
Control-Flow

function* range(start, end, step) {
  while (start < end) {
    yield start;
    start += step;
  }
}

let evens = range(0, 10, 2);
console.log(evens.next().value); // → 0

for (let n of evens) {
  console.log(n); // → 2, 4, 6, 8
}

Data Structures#

Sets

let alphabet = new Set();
alphabet.add('A').add('B').add('A');
alphabet.size; // → 2
alphabet.has('A'); // → true
for (let key of alphabet.values()) // insertion order
  console.log(key);

Maps

let member = new Map();
member.set('id', 42);
member.set(state, 'accepted');
member.get(state); // → "accepted"
member.size; // → 2
for (let [key, val] of member.entries()) console.log(key + ' = ' + val);

Typed Arrays#

Arbitrary byte-based data structures
Network Protocols
Cryptography Algorithms
File Format Manipulations

let buffer = new ArrayBuffer(24); // generic

let amountDue = new Float32Array(buffer, 20, 1);

let imageData = new Uint8ClampedArray([42, 1337]);
console.log(imageData[1]); // → 255

Additional Built-in Methods#

Object Property Assignment
Array Element Finding
String Repeating and Searching
Number Type and Safety Checking
Number Comparison / Truncation / Sign Determination

Object.assign({ a: 1 }, { b: 2 }, { c: 3 }); // → { a: 1, b: 2, c: 3 }
[1, 3, 4, 2].find((x) => x > 3); // → 4

'aloha'.repeat(3); // alohaalohaaloha
'/networks/lua/latest'.includes('networks'); // → true
'reddit'.endsWith('it'); // → true
'facebook'.startsWith('face'); // → true

Number.isNaN(NaN); // → true
Number.isFinite(Infinity); // → false
Number.isSafeInteger(10007199254740992); // → false
Number.EPSILON; // instead of 2.22e-16

Math.trunc(-42.7); // → -42
Math.sign(-7); // → -1

Promises#

Async Callback
Chaining

let networkPromises = this.networks.each((network) => {
  return new Promise((resolve, reject) => {
    return network.fetch((response) => {
      if (response.body) {
        resolve(response.body);
      } else {
        reject(response.error);
      }
    });
  });
});

Promise.all(networkPromises).then(
  (data) => {
    NetworkActions.setNetworks(data);
  },
  (error) => {
    errorHandler(error);
  },
);

Meta Programming#

Proxying

var artist = { name: 'Michelangelo', paintings: 253 };
var interceptor = {
  set: function (receiver, property, value) {
    console.log(property, 'is changed to', value);
    receiver[property] = value;
  },
};

artist = Proxy(artist, interceptor);
artist.paintings = 254; // → paintings is changed to 254

Reflection

let obj = { a: 1 };
Object.defineProperty(obj, 'b', { value: 2 });
obj[Symbol('c')] = 3;
Reflect.ownKeys(obj); // → [ "a", "b", Symbol(c) ]

What is next?#

ES7
- Object.observe
- Async (Event Loop Concurrency)
- Comprehensions
- Guards (user defined invariants!)
ES8
- a long ways out
- Macros (make your own syntax)
- Parallel arrays

Finito#

Compatibility Table: https://kangax.github.io/compat-table/es6/
Future of JS: https://www.2ality.com/2011/09/es6-8.html
REPL: https://babeljs.io/repl/#?experimental=true
Feature List https://es6-features.org

boxviewrb

Wed, 11 Jun 2014 20:06:09 GMT

onStart#

I took a bit of a blogging hiatus during my vacation recently. I used this time to start working on an open source project called boxviewrb. Boxviewrb is a Box View API Wrapper written in ruby. It uses the HTTParty gem for network calls, and also supports multipart uploading. Alternative gems for Box View do exist. However, they are incomplete implementations, some old that have not been updated (crocodoc), and others that just did not offer a complete feature set. Boxviewrb works with every request and feature that the Box View API has documented. Test coverage is minimal, only some of the requests have tests, but I am meaning to add more coverage in the future. I attempted to make the documentation as readable and self explanatory as I possibly could. This is my first time ever releasing a piece of open source software, and it certainly will not be my last. Instructions on how to contribute can be found at the bottom of the readme.

onFinish#

In previous articles I wrote about communicating with the Box View API using Net::HTTP. Based on this primitive example I was able to make an open source gem. If you read over my documentation, you will notice the convenience methods. They came in handy when placing Box View in a production application. At Lua we now have document viewing right in the browser! If you would like this feature in a site you’re running, give my gem a try. As always if you have any concerns or questions drop a comment below.

Sinatra Assets

Mon, 26 May 2014 15:32:56 GMT

onStart#

Rails is one of the most popular frameworks right now. It contains a lot of magic, and that can often be credited to its asset pipeline. Frequently when I think of Sinatra I think of it as a slim downed version of Rails. It has its uses, and so does Rails, but what if we wanted to combine Sinatra with an asset pipeline. I decided to do a little digging, and after doing a little research, I discovered that their is only one good solution that exists right now. It is called the Sinatra AssetPack.

Sinatra AssetPack#

In order to get started using the Sinatra AssetPack you will need to add it to your Gemfile.

gem 'sinatra-assetpack', :require => 'sinatra/assetpack'

Then run bundle (or bundle install), and let it install. Once installed you can start taking advantage of the Sinatra AssetPack. I added it to the base of my Sinatra app, I would recommend you do the same.

require 'sinatra/base'
require 'sinatra/assetpack'

class MyApp < Sinatra::Base
  set :root, File.dirname(__FILE__)
  set :views, settings.root + '/views'
  set :public_folder, settings.root + '/public'

  register Sinatra::AssetPack

  assets {
    serve '/js',     from: 'app/js'
    serve '/css',    from: 'app/css'
    serve '/images', from: 'app/images'

    # Serve up JS per request
    js :app, '/js/app.js', [
      '/js/vendor/**/*.js',
      '/js/lib/**/*.js'
    ]

    # Serve up CSS per request
    css :application, '/css/application.css', [
      '/css/screen.css'
    ]

    # jsmin, yui, closure or uglify for js compression
    js_compression  :uglify
    # simple, sass, yui, or sqwish for css compression
    css_compression :sass
  }

  get '/' do
    haml :index
  end
end

With the Sinatra AssetPack you can minify/obfuscate your js and css files. It will help you clean up your routes as well. By serving up only the files you need, you can specify exactly what js and css files for your Sinatra app when hitting a particular route. I found out of all the available options, this was the simplest

The Pipeline#

After configuring your app like I did above, you will be able to use the pipeline in your static files. In this example I am using haml. It is very simple to include your js/css/haml files using this type of pipeline.

= haml :browser_compat
%html
  %header
    = haml :header # header contains != css :application
  %body
    .container
      .navigation
        = haml :navigation
      .stage
        = haml :stage
      .footer
        = haml :footer
    #js_footer
      != js :app

This results in very clean and readable haml. The pieces here are reusable, and by following this pipeline you start to modularize your Sinatra application. I hope more apps use this, as it brings the magic of Rails to Sinatra apps, which tend to be more simplistic.

onFinish#

Not everyone will need an asset pipeline in their web app. This is for those that require a clean and reusable code base for an app that is based on Sinatra. I find that modularizing your js and css will help a lot. Especially when you get obfuscation for free with it. Sinatra can be a powerful web application framework, and tools like this can make it even better. If you require any assistance setting up Sinatra AssetPack let me know.

BoxView

Sun, 18 May 2014 21:51:11 GMT

onStart#

The BoxViewAPI is useful for displaying documents in the browser without needing to do any heavy lifting. You can quickly turn any PDF, MS Document, or MS PowerPoint into HTML and display it inline on your website. The HTML is hosted by Box, and you can easily display this on your site by using an iFrame. Alternatively you could download the HTML and display it with viewer.js. Make sure you signup and create a BoxView app before you start. The app will have an API key that you will need in all requests you make with Box. I am implementing it in Rails, but you could do this on any backend in exactly the same fashion.

Upload a Document#

The first step to making a viewable document is uploading the file to box. I decided to use the net::http library when communicating with the BoxViewAPI. However, you can use any RESTful lib. RestClient is another popular one. Then make a post with the necessary headers. The response if successful will contain a document id.

  # Headers used throughout these examples
  # Get YOUR_API_KEY from the box view application page
  BOX_HEADERS = {
    'Authorization' => "Token #{YOUR_API_KEY}",
    'Content-type' => 'application/json'
  }

  def upload_document
    document_uri = URI.parse("https://view-api.box.com/1/documents")
    data = {
      'url' => original_url
      # If thumbnails are desired:
      #, 'thumbnails' => '100x100'
    }
    http = Net::HTTP.new(document_uri.host, document_uri.port)
    http.use_ssl = true
    request = Net::HTTP::Post.new(document_uri.path, BOX_HEADERS)
    request.body = data.to_json
    response = http.request(request)
    parsed = JSON.parse response.body
    document_id = parsed["id"]
    return document_id
    # or self.update_attribute :document_id, document_id
  end

Create a Session#

Now that you have a document id, you can make upload_document return the id or just save it to a model (This is useful if you’re interested in implementing WebHooks). Next you can use that document id to create a session which will begin the conversion of the document, and let you know when it is ready. If you are using this in your web app frequently, I recommend using Sidekiq to offload all these network calls and possible database saves to an asynchronous process. When successful, box will return a 201, which means the document is ready for viewing. If you don’t get a 201 you will get a 202 or 400 response code. A 202 means the document is not yet ready for viewing. A 400 means the conversion has failed. If you’d like to view your file at this point, just head over to [https://view-api.box.com/1/sessions/{session id}/view?theme=light](https://view-api.box.com/1/sessions/{session id}/view?theme=light), where session id is the id you get from the 201 response.

  def create_session(document_id)
    session_uri = URI.parse("https://view-api.box.com/1/sessions")
    data = {
      "document_id" => document_id
      #, "expires_at" => Time.now + 1.hour
      # You could specify an expiration date.
    }
    http = Net::HTTP.new(session_uri.host, session_uri.port)
    http.use_ssl = true
    request = Net::HTTP::Post.new(session_uri.path, BOX_HEADERS)
    request.body = data.to_json
    response = http.request(request)
    case response.code
    when "201" # Done converting
      parsed = JSON.parse response.body
      session_id = parsed["id"]
      return session_id
      # or self.update_attribute :session_id, session_id
    when "202" # Session not ready yet
      time = response['Retry-After'].to_i
      # here you would retry based on the time variable
      # You could use sidekiqs perform_in method, or just sleep
    when "400" # An error occurred while converting the document or the document does not exist
      Rails.logger.debug "Document failed to convert - #{response.body}"
    else
      raise "BoxSessionError #{response.inspect}"
    end
  end

Generate a Thumbnail#

A cool feature BoxView has is thumbnail generation. It can return a thumbnail of any size 16-1024 wide by 16-768 high. This way you can see a preview of the document before displaying it to a user. The BoxView API only requires a height and width, and the document that you want the thumbnail generated from.

  def generate_thumbnail(document_id)
    query_params = "?width=100&height=100"
    thumbnail_uri = URI.parse("https://view-api.box.com/1/documents/#{document_id}/thumbnail")
    http = Net::HTTP.new(thumbnail_uri.host, thumbnail_uri.port)
    http.use_ssl = true
    thumbnail_path = thumbnail_uri.path + params
    request = Net::HTTP::Get.new(thumbnail_path, BOX_HEADERS)
    response = http.request(request)
    case response.code
    when "200" # Valid thumbnail
      thumbnail = response.body
      # Now upload the thumbnail to another server
      # or use it however you would like
    when "202" # Thumbnail isn't ready yet
      time = response['Retry-After'].to_i
      # Same as a session 202, sleep or worker
    when "400" # Width/Height are invalid
      Rails.logger.debug "400 Box Thumbnail Width x Height Invalid - #{response.body}"
    else
      raise "BoxThumbnailError #{response.inspect}"
    end
  end

Box offers a chance of producing the thumbnail earlier in the process. If you state the width and height earlier when uploading the document, box will have the thumbnail ready by the time you call generate_thumbnail. After getting the thumbnail from the response you could upload it to your own server.

onFinish#

My examples above are all in ruby, but their also exists a great python project on GitHub that shows how to do the same. If you needed help getting started with BoxView I hope you no longer do. If you require WebHooks with BoxView, they aren’t very difficult. Just email api@box.com with your API key and domain to send the responses to a controller. If you want to test that WebHooks work in your testing environment, I recommend using ngrok. It helped me confirm everything was in a good working condition before using it in other environments. As always, if you need help let me know.

Fragment Factories

Sun, 11 May 2014 20:22:59 GMT

onStart#

Android fragments can become a big garbled mess of spaghetti code. I have seen it happen again and again. Other developers I have worked alongside and I agree that generating fragments with the use of factory methods will make your code cleaner and more reusable. Although the material I go over here will mainly pertain to Android, it should help anyone who understands the basics of java. Fragments are the butter to the bread of android apps. They allow for a disconnect of the inner workings of your application. When instantiating a new instance of a fragment you will often want to pass in a bundle of arguments that can be used throughout the lifetime of that fragment. By using factories you create a special place for argument passing to occur. Things become more interesting as you dive deeper into more complex fragments. For now we will begin by taking a look at extending the Android ListFragment.

public class BaseListFragment extends ListFragment {

  /* No Base Factories */

  /* You can override the usual onCreate/onPause/onResume methods here. */

}

Lists of information are some of the most important screens in applications these days. Whether they are on your phone or your desktop, lists are where it is at. Just go to google or reddit and you can see how important a good list is. An Android ListFragment is the tool given to you for free in order to make a list in the android ecosystem. By creating a base list fragment in your android application you let yourself abstract the tools you need in every list away from the busy work. It becomes especially important to do this as the application you are building will surely get more and more complicated. It always happens, and helping yourself early in this regard can only make the development process easier.

Fragment Generation#

So now that we have our BaseListFragment we can start generating our fragments by extending that class. We are able to override any of the methods we retain from our extended class, and we can add any new ones we may need as well. As you might have already realized I chose not to put a factory in my base class. Some may argue that the base class should be able to be used just like any of the other classes that extend it, but in this case I chose to leave the factory out. By not having a Factory method in the base, you restrict yourself to only generating classes that have extended your base. Leaving your base practically unusable otherwise. Feel free to go against the grain here and try doing this how you like. But I believe that factories do not belong in base classes. Look at the class below for an example of how to create factories in your fragments.

public class CatGifListFragment extends BaseListFragment {

  /* Just a unique string identifier for use in a fragment transaction. */
  public static final String FRAGMENT_CAT_GIFS = "fragment_cat_gifs";

  public static CatGifListFragment newInstance() {
    CatGifListFragment f = new CatGifListFragment();

    Bundle args = new Bundle();
    /* Any extra arguments you might want to add. */
    f.setArguments(args);

    return f;
  }

}

New Instance#

Now that our CatGifListFragment has a method that can return an instantiated copy of itself, let’s show it off. In order to show a fragment we can use a fragment manager in an Activity after some user interaction. Below I have an example of a user clicking on a view element called list_cats. This could be anything, but the idea is that it will display our fragment on screen after being clicked. By calling newInstance on our CatGifListFragment we are returning an instantiated version of the class that will contain any arguments we pass into the newInstance method. Simply call show after generating the fragment to display it.

public class CatActivity extends BaseActivity {

  /* After some user interaction lets show the cat gif list fragment. */
  @Override
  public void onClick(View v) {
    int id = v.getId();

    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();

    switch (id) {
      case R.id.list_cats:
        /* You would pass in any arguments you wanted access to in the fragment here. */
        CatGifListFragment catGifListFragment = CatGifListFragment.newInstance();
        catGifListFragment.show(ft, CatGifListFragment.FRAGMENT_CAT_GIFS);
        break;
      default:
        break;
    }
  }

}

This is just one example of displaying a fragment. There are countless ways that you could display a fragment, but the way in which you instantiate it is vital. Notice that CatActivity extends a base class as well. Keeping this in mind throughout your application will lead to cleaner code. Cleaner code will make your development process improve, so please keep this in mind throughout every piece of work your produce.

onFinish#

If you find yourself reusing similar fragments over and over these tips will be even more helpful to you. Dialog and List fragments being some of the most frequent ones I see in android. Not everyone shares as many cat gifs as my coworkers do, but when they do I want them to be doing it efficiently. Look over your android apps, and review how you instantiated your fragments in your activities. Most android apps I have seen are doing this horribly wrong. If you have a cleaner and more efficient way of instantiating them than this, I would love to hear about it. Also if you have any questions, feel free to ask as always!

Promises and More

Mon, 05 May 2014 12:30:53 GMT

onStart#

I’ve recently begun using promises in my javascript and even now I understand how useful they can be. I have come across many tools in the last year that I have found to be helpful. Certain situations have just appeared very hard, and then suddenly the perfect tool would allow me to continue on and overcome a hurdle. Promises are a tool such as that.

jQuery Deferreds#

Although jQuery Deferred promises aren’t A+ Compliant, I still find them to be very useful. Often when writing Backbone.Marionette apps I have needed to make a major change to a view and immediately after do some work. This happens in almost ever view in every app I have worked on. Say you need to navigate to another part of the app but first require closing the view the user is looking at. Calling the close or remove method on your view will often do the trick, but when you have extra work, timing becomes important. In many examples, I see people calling the event, and then executing the close. This does work, but is only working because of timing. If you use a jquery deferred you can execute the event after the closing of the view.

$deferred = $.Deferred()
$deferred.resolve @close()
$deferred.done -> App.vent.trigger 'show:dialog'

Image Loading with jQuery Promises#

Many libraries exist to load images, but I like to rock my own. Using jQuery Deferred promises you can go a step further with image loading. Javascript offers an image object which has a few callbacks on it. onLoad, onError, and onAbort can be used with jQuery promises so that you can be sure that the image has succeeded or failed at loading properly.

imageLoader = (url) ->
  loadImage = (deferred) ->

    loaded = ->
      unbindEvents()
      deferred.resolve image

    errored = ->
      unbindEvents()
      deferred.reject image

    unbindEvents = ->
      image.onload = null
      image.onerror = null
      image.onabort = null

    image = new Image()
    image.onload = loaded
    image.onerror = errored
    image.onabort = errored

    image.src = url

  # promise causes the resolve/reject methods to not be accessible.
  $.Deferred(loadImage).promise()

With the above imageLoader you could do something like the example below.

$promise = imageLoader 'http://catgif.com/cat.gif'
$promise.done (image) -> $('.loading').replaceWith image
$promise.fail -> $('.loading').replaceWith '<img src="sadface.png"></img>'

A+ Promises#

A promise is an eventual result of an asynchronous operation. Many people have argued over exactly what the terminology should be and how the inner workings should work. If you aren’t looking to argue about this, and just want to take advantage of promises. I recommend starting with q. Q is an A+ compliant library, and it works using the expected when then format.

# Normal Q Promise structure
Q.fcall step1
.then step2
.then step3
.then (value) -> console.log value
.catch (error) -> console.log error
.done()

# Any function that returns a promise
promise = @climber()
promise.when @climbAMountain() # A when is a static then
promise.then @fallDown()
.catch (error) ->
  # A note on Q promises:
  # It will catch any errors while you are climbing or falling
.done()

# Q also offers a try catch finally block
promise = @anotherPromise()
promise.then # try some work
promise.catch # catch some error
promise.fin # finally do thing

Q is a very flexible promise library. It allows you to chain promises and execute arrays of promises. It is easy to use, and combined with coffeescript becomes one of the most readable solutions.

Tools#

Promises are great and have helped dig me out of a lot of holes. Having helpers to assist you along the way when building a web app makes development more enjoyable and relaxing. I’ll share some of the other tools that I use to help me along the way. Many people might be thinking why build my own when I can just download something like UnderscoreJS. Libraries are great, but occassionally you come up with a great piece that you just carry with you. I recommend building your own set and improving upon them. Share them with the developers you work with and just spread the word.

# Cleanup video and audio elements when you are done with them.
cleanupMedia: ($media) ->
  return unless $media.length
  $media[0].pause()
  $media[0].src = ''
  $media.children('source').prop 'src', ''
  $media.remove().length = 0

# Methods to check for HTML5 Video and Audio Support
supports_video: -> !!document.createElement('video').canPlayType
supports_audio: -> !!document.createElement('audio').canPlayType

# Move the cursor to the end of an input
$.fn.focusToEnd = -> @each ->
  v = $(this).val()
  $(this).focus().val("").val v
# Then do this:
$('.input').focusToEnd()

# A contains method for the String class
if not String::contains then String::contains = -> String::indexOf.apply( this, arguments ) isnt -1
# Use it like so:
"apple".contains 'app' # returns true

onFinish#

A promise is not the swiss army knife of javascript tools. However it will get you out of hard and ugly situations with asynchronous code. $.ajax, $.post, and $.get all return deferreds that you can then listen in on. That is where the .done, .fail, .always methods come from in asnychronous jquery. Promises are a great way to finish the job, and at any time. Promise libraries exist other than Q, and I would recommend reading about the various other ones before deciding on Q. May promises help you in your developments. If you have any questions feel free to ask, I will respond, I promise.

HTML5 Video and Audio

Mon, 28 Apr 2014 16:27:05 GMT

onStart#

HTML5 makes placing an audio or video stream into your web app simple. However, not all browsers can use HTML5 (IE > 8, Chrome > 3, FF > 3). Many great solutions such as VideoJS and AudioJS try to alleviate that issue. In this article I will be going over how one might implement HTML5 video and audio in a dynamic and reusable fashion. The various features available when templating, and the tribulations when working with video and audio in javascript.

Video and Audio Templates#

To begin let’s see what HTML5 video and audio tags might look like in a template.

# (poster, height, and width are video only features)
%video#movie{height: 640, width: 480, poster: "some.png", controls, autoplay, loop}
  %source#mp4{src: 'rickroll.mp4', type: 'video/mp4; codecs="avc1.42E01E, mp4a.40.2"'}
  %source#ogg - # you can specify as many of these as you like, or just one.
  Your browser does not support the video type or codec.

%audio#speakers{preload: auto, controls: true, autoplay: true, loop: true}
  %source#mp3{src: 'getlucky.mp3'}
  Something terrible has occurred, run for your lives!

Above a HAML file contains an HTML5 video and audio tag. Let’s go over some of their attributes. Looking at the video tag we can see I specified a height and width just like a div (video only). The controls attribute tells the browser to show the built in controls, it takes a boolean value. Autoplay makes the browser play the media automatically, and it takes a boolean value. Loop causes the media to play indefinitely, and it takes a boolean value. The poster attribute displays an image until the first frame of the video has loaded. An external or local image can be specified (video only). The preload attribute, which can be one of three things, none | metadata | auto. The media can also take a src attribute, but when dynamically controlling html5 video/audio it is easier to place a source tag underneath and specify the source manually or from JS. The source tag also allows for specifying the content type and codec of the video that will be playing. Lastly you can specify in plain text an error message, if the media you are trying to play is not supported. A list of all the video attributes and audio attributes can be found on MDN.

Dynamic Video and Audio#

Having control over the video and audio that may be playing is a desirable feature. Unfortunately you may want to use something jQuery to help you do this. Currently jQuery does not support HTML5 video and audio. You are going to have to use straight javascript (in my case coffeescript).

# You cannot use jQuery to do this:
# @$('#movie').load()
# However you can get the first DOM element.
movie = @$('#movie').get(0) # If you want to retain jQuery, use eq(0) instead.

# Optionally set the source in JS.
@$('#mp4').get(0).src = '/rickroll.mp4'

# First you will need to load the video.
movie.load()

# Check if the video can be played, before playing it.
movie.canPlayType('video/mp4') # returns 'maybe', 'probably' or ''

# Then you can play it.
movie.play()

# To pause you can call pause or trigger the event
movie.pause() # or @$('#movie').trigger 'pause'

# For stopping playback all together, their are a few solutions.
movie.pause()
movie.currentTime = 0
# or
movie.src = ''
# or
@$('#movie').remove()

# Several events exist that you can listen in on.
# How do I know when the first frame has loaded?
movie.addEventListener 'loadeddata', -> console.log 'Done loading!'
# How can I calculate the progress of a video?
movie.addEventListener 'progress', -> console.log @buffered.end(0) / @duration
# How do I know how far along the video is?
movie.addEventListener 'timeupdate', -> console.log @currentTime / @duration

All of the examples above would also work for audio, just replace the #movie id with the #speakers id. HTML5 is very feature rich. You can get just about any of the information that you could want when using these APIs. I only went over a few of the events that HTML5 offers. I recommend reading over the rest to get a better grasp of the available tools.

# For audio you can use the built in Audio Constructor as well.
sound = new Audio ['http://musicdomain.com/getlucky.mp3']
# Preload gets set to auto by default.
# Sources aren't available as a fallback, so manually detect compatibility.
unless sound.canPlayType? 'audio/mpeg'
  # An alternative like flash/silverlight goes here.

Backbone Example#

Before wrapping up let’s take a look at a real life example. This would be in the case that you were using Backbone, but any structural web application would work similarly. Below I have built a tiny MP3 player that is being controlled and styled through a backbone view, with custom play and pause button ids.

class MP3Player extends Backbone.View
  template: 'mp3_player'
  events:
    'click #play'  : 'play'
    'click #pause' : 'pause'
  initialize: -> @loadAudio()
  loadAudio: ->
    @$speakers = @$('#speakers').get(0)
    @$('#mp3').get(0).src = 'http://musicdomain.com/getlucky.mp3'
    @load()
  load: -> @$speakers.load()
  play: -> @$speakers.play()
  pause: -> @$speakers.pause()

I found that when using HTML5 video and audio in a structural app, the code is more readable. Through a combination of backbone and coffeescript you can create a clean and concise video or audio player. Wrapping the video or audio tags in a container allows you to customize many aspects. Which allows for things like custom control interfaces. Using the timeupdate event you could display a message to the user as they progress or finish streaming. Things can get tricky at times because of the lack of jQuery support. But keep in mind that if you fall back to basic javascript things will work out just fine.

onFinish#

Some may argue that the HTML5 Video and Audio APIs aren’t worth introducing yet. Many implementations always have to offer a fallback option using Flash or an alternative like Silverlight. If you take a look at Soundcloud or Youtube, to this day you have to go into some experimental mode just to turn on HTML5 media playback. On top of that browsers differ in their implementation of the HTML5 API and so you have to tiptoe around when using it. This has been the case for most internet related things since the beginning of time, so I doubt this will deter anyone from using it. If you find yourself struggling feel free to contact me. Also the VideoJS and AudioJS libs take care of the majority of failure cases and allow for easy styling out of the box.

Jasmine and Teaspoon

Mon, 21 Apr 2014 23:59:13 GMT

onStart#

In the case of writing tests for your javascript/coffeescript apps you will find that Jasmine is one of the best options. It is easy to add to by improving its matchers, and it is flexible enough to test more difficult subjects like asynchronous calls or mock/stub events and data. If you are currently looking for a way to test the front end of your website or javascript app you will not regret using jasmine to do so.

Getting Started with Teaspoon#

When testing with Jasmine I found it easiest to use Teaspoon alongside to easily setup a testing environment. Teaspoon has many benefits. They offer support for command line testing as well as testing in the browser. Teaspoon automatically generates a spec helper so that you can easily require your front end app. Combine this with Stub/Mocking with jasmine-sinon and jasmine-jquery and you will have all the testing tools you could want on the front end.

# Add these lines to your Gemfile
group :development, :test do
  gem "teaspoon"
  # Teaspoon can use selenium or phantomjs
  # gem "phantomjs", ">= 1.8.1.1"
end

After setting up your gemfile, you can run bundler. Then execute the following line in your terminal. You can specify a framework, in my case I am using Jasmine, but Teaspoon supports other as well, such as Mocha. I also love to use coffeescript when testing, so I append —coffee to the end of the command to tell Teaspoon I will be writing coffee files.

rails generate teaspoon:install --framework=jasmine --coffee

You can run your tests by visiting http://localhost:3000/teaspoon. Where 3000 is the port you run your server on. Alternatively you can run the Teaspoon test suites by typing rake teaspoon in the command line. They both have benefits, but ultimately you may find yourself wanting to run your tests using Guard. That way you can run your tests while you develop. If you are interested in using Guard with Teaspoon, I recommend reading about guard-teaspoon.

Writing Jasmine Tests#

Now that you have setup Teaspoon you can get to the fun part. I recommend reading Jasmines documentation, they have a lot of great examples on the various types of tests you may come across when testing a front end. In my case below, I am testing my backbone model Person, and the attributes that exist on it by default. If you want open a new file in the jasmine folder that Teaspoon generated. In my case it would be person_spec.coffee.

describe "Person", ->

  # If you want to do something before each test
  beforeEach ->
    person = new People.Person()

  it 'should be alive', ->
    expect(person).toBeDefined()

  it 'should have a name', ->
    expect(person.get('name')).toBeString() # underscore method

  it 'should have a favorite food', ->
    expect(person.get('food')).toBe("Pizza")

  it 'should have an identification', ->
    expect(person.get('id')).toBeNumber()

  # If you want to write the boilerplate
  # for a test you haven't finished yet
  xit 'can die', ->

  # Testing a method on a model
  it 'should have a creator', ->
    expect(person.creator()).toBe("Vinny")

Creating Matchers#

So now that you have written a test, maybe you want to expand the tools you have at your disposal when testing in Jasmine. Matchers make it easy to create new tools you can use for testing. If you have the UnderscoreJS library, you can easily add some matchers to Jasmine that will make testing better. In order to start adding matchers, open up your spec_helper file that Teaspoon generated. At the end of this file you can add any matchers you might want when writing your tests.

beforeEach -> # Executes this code before each test.
  @addMatchers # Tells Jasmine to add these matchers
    toBeOfType: (type) ->
      return typeof @actual is type # @actual points to the expected value
    toBeNaN: ->
      return _.isNaN @actual
    toBeDate: ->
      return _.isDate @actual
    toBeEmpty: ->
      return _.isEmpty @actual
    toBeArray: ->
      return _.isArray @actual
    toBeObject: ->
      return _.isObject @actual
    toBeRegExp: ->
      return _.isRegExp @actual
    toBeFinite: ->
      return _.isFinite @actual
    toBeString: ->
      return _.isString @actual
    toBeNumber: ->
      return _.isNumber @actual
    toBeElement: ->
      return _.isElement @actual
    toBeBoolean: ->
      return _.isBoolean @actual
    toBeFunction: ->
      return _.isFunction @actual
    toHaveArguments: ->
      return _.isArguments @actual

By using a library like underscore you retain the testing environment that Jasmine creates, even when doing comparisons like expecting a handful of arguments. By adding matchers your tests become more clear and concise. Being able to write thin self explanatory tests is priceless. Especially when the magic is coming from a spec helper that you yourself have written.

onFinish#

Hopefully this brief overview of Teaspoon will give you the jump start you need to get into front end testing. Testing is invaluable, and I recommend doing it for more than just your front end if you can. If you have any problems while testing with Jasmine or just want some help, leave a comment below.

Client-Side EXIF

Mon, 14 Apr 2014 09:59:53 GMT

  1        2       3      4         5            6           7          8

######  ######      ##  ##      ##########  ##                  ##  ##########
##          ##      ##  ##      ##  ##      ##  ##          ##  ##      ##  ##
####      ####    ####  ####    ##          ##########  ##########          ##
##          ##      ##  ##
##          ##  ######  ######

onStart#

Images with exif data are often not that easy to handle. Manipulating images on the client and passing around metadata can be a slow and painful process. I have used many of the options available to one when trying to get exif in JavaScript. This is a review of several viable options for getting exif from an image.

For testing purposes throughout this review I recommend using images with exif data intact. Dave Perret has a pack of them over on github that you can download.

Image Orientation in Firefox#

Althought this doesn’t deal with extracting EXIF, it is worth mentioning for those looking for a solution to orientation problems. The only browser which actually allows for image orientation correction right now is Firefox 26 beta or above. Adding this feature is very simple. Just apply the image-orientation style using css to any image tag. Unfortunately chrome has yet to implement this feature and the only way to see correctly oriented images is by having an image at the top level of the DOM. As time passes this feature will become adopted, and possibly images will be rotated automatically.

<img style="image-orientation: from-image" src="image.jpg" />

See for yourself how this works in my example. Firefox will return the best results, but you should be able to try it in any browser you have installed. Documentation for the image-orientation style can be found on w3.

Load-Image Library#

This library is great at, you guessed it, loading images! It has the idea of mix and matching behind its implementation. You can grab the exif and the main library and start parsing data with very few lines of code. After parsing the exif data out, you have to load the image again. This isn’t great for performance but it does work very well. Try it out for yourself here.

# Parsing the Metadata
loadImage.parseMetaData file, (data) ->
  options = {}
  if data.exif
    options.orientation = data.exif.get('Orientation')
    options.canvas = true # tells loadImage we want a canvas returned
  # Load the Image with new options
  loadImage file, (image) ->
    $('some_div').append(image)
  , options

# You could also scale an image
canvas = loadImage.scale image,
  left: 0
  top: 0
  sourceWidth: image.width
  sourceHeight: image.height
  maxWidth: target_width
  maxHeight: target_height

As you can see the Load-Image lib allows for a lot more than just exif extraction. You can manipulate images in many ways using this tool. The downsides are that this doesn’t use a web worker, so you cannot count on this when doing other performance heavy operations. If you would like to test this out for yourself, they have a great demo.

EXIF and BinaryAJAX#

Although old, these two files will allow you to extract EXIF meta data from JPEG images. This is best used with the FileReader API available on most modern browsers. EXIF and BinaryAJAX are available at http://nihilogic.dk . Below is an example of using the FileReader to load the image, and then extract the exif with EXIF and BinaryAJAX.

image = @files[0] # Get the first file from the user
reader = new FileReader
reader.onloadend = ->
  exif = EXIF.readFromBinaryFile new BinaryFile @result
reader.readAsBinaryString image

The advantage of this library is that it doesn’t require much, and you do not have to load the image many times. All it really requires is the use of the File API. The downside is you don’t get the advantages of manipulating the images, or resizing properly. All you get is the EXIF data. Seeing as this one is outdated, I would just give it a try or try the more code friendly example. Visit the github page here for more information.

Flickr’s EXIF Extraction#

Flickr has a great write up in regards to extracting the metadata using web workers. Web workers appear to be a very performant option. Similarly to the example above, you need to use the FileReader API, but more efficiently slice off only the part of the image that contains the exif data. When working with the exif data in a web worker, the EXIF tag for orientation will be at offset 0x112.

# Slice up the section of the file that contains the exif (128 KiloBytes = 131072 Bytes)
if file.slice
  filePart = file.slice 0, 131072
else if file.webkitSlice
  filePart = file.webkitSlice 0, 131072
else if file.mozSlice
  filePart = file.mozSlice 0, 131072
else
  filePart = file

# Read part of the file, then send it to our worker for processing
reader = new FileReader
reader.onload = ->
  # Refers to a worker you must define
  jobBlob = new Blob [workers.exif_processor], {type: "text/javascript"}
  worker = new Worker URL.createObjectURL jobBlob
  worker.addEventListener 'message', (e) ->
    console.log "Exif Orientation Data:", e.data
  worker.postMessage
    binary: @result
reader.readAsBinaryString filePart

Using Web Workers to process the exif data is the fastest way to correcting your images. You may even be able to get web workers working with one of the examples above. Flickr used to acquire most of the metadata server side, but now they moved over to doing it on the client. Hopefully this will convince others to do the same, and we can get the webs images looking better than they have in the past.

onFinish#

Consistent exif orientation handling is wack on the web, a great article on this topic, goes into detail about the current state of orientation handling. If you think you know a better way, or an alternative to the methods I went over here, please let me know. Extracting EXIF is hard enough, having to manipulate images after is overkill.

Aviary's FeatherJS in Backbone.Marionette

Mon, 07 Apr 2014 01:01:35 GMT

To get started head over to the Developer Page and sign up. Select the HTML 5 app and generate an api key. Place featherjs in a script tag or download it.

Now in your Backbone.Marionette app you are going to either create a new ItemView or navigate to an existing one you want aviary to be launched from.

class App.AvatarView extends Backbone.Marionette.ItemView
  template: 'avatar'
  className: 'avatar_view'

Initialize Aviary by creating an instance of Feather JS. Do this in the initialize method of the ItemView. Here we construct what Aviary’s Editor will do throughout its use. When the user finishes saving the photo, a url is returned. You are left with several options. Insert the url into the DOM using the image id, save the new url to an attribute on your Backbone model, or directly post the url to your server. Make sure you store your api_key somewhere so you can access it from anywhere you might need to launch aviary. For this example I’ll store it in window.aviary_api_key.

initialize: ->
  @featherEditor = new Aviary.Feather
    apiKey: aviary_api_key
    apiVersion: 3 # The latest api version
    tools: ['stickers', 'crop']
    onSave: (id, url) ->
      @model.save
        avatar_url: url
      return false # ignores the save/confirm dialog
    theme: 'light' # dark by default
    noCloseButton: true # You can force the user to continue using aviary this way.

Aviary also provides callback methods like onClose and onReady for additional control during various points of user interaction. Another useful param is postUrl. This allows you to post the newly edited photo to a route on your server or wherever you would like.

You’re going to need a method that can start aviary from an event or some other place in your view. Let’s call this method launchEditor.

launchEditor: (id, src) ->
  # load a url now or pass it into this function
  @featherEditor.launch
    image: id
    url: src
  return false

If you would like to add a default cropping ratio you can do so by adding a ‘forceCropPreset’ to the params on launch like so.

@featherEditor.launch
  image: id
  url: src
  forceCropPreset: ['My Default', '1:1']
  forceCropMessage: 'Please Crop your Avatar'

At this point you can test that aviary is properly launching after calling the ‘launchEditor’ method. You may want to add a click listener to launch it. If you have a class named avatar, you could add an event to launch it.

events:
  'click .avatar' : 'launchEditor'

Aviary has documentation on implementing feather. I don’t recommend reading the entire thing. Only pieces of it are useful for specific instances of aviary. I went over some of the more useful features you may want when using it with Avatars. But you can mix and match Aviary’s editor to fit your needs. Take a look at the various tools the editor offers to see what I mean.

Remember, every external library comes with its hardships. Although it seems very simple to implement, Aviary only allows external resources to be used as (a publicly available file that they process) the url source. The url they return to you is always one from there servers. So if you don’t feel comfortable with aviary touching your users data remotely, I would look for other options. Such as manually cropping photos using the HTML 5 Canvas.

Note: I had trouble with IE9, they claim to support it but I received ‘Not Enough Storage’ errors when launching Feather in IE. It appeared to be an issue with cascading style sheets, let me know if you have a similar result.

Dev Continuum

iPod Classic Revival

Research#

Repair#

Upgrade#

Software#

What’s next?#

Hardware Transcoding

Research#

Purchase#

Installation#

Nvidia Drivers#

Plex and Docker#

Was it all worth it?#

Hackintosh

Processor#

Motherboard#

Storage & Memory#

Graphics Processor#

WiFi & Bluetooth#

Case & Cooling & Power#

Results#

React Image Hook

Programming Phoenix

Coffee to Babel in 24 hours

CJSX-Codemod#

Decaffeinate#

React-Codemod#

ESLint#

Others#

Blog Performance

The Witcher

ECMAScript 6 - Harmony

18 Years of Specifications#

ECMAScript 1 through 5#

Transpiling#

Constants#

Scoping#

Arrow Functions#

Extended Parameter#

Template Strings#

Extended Literals#

Enhanced Regular Expression#

Enhanced Object Properties#

Destructuring Assignment#

Modules#

Classes#

Symbol Type#

Iterators#

Generators#

Data Structures#

Typed Arrays#

Additional Built-in Methods#

Promises#

Meta Programming#

What is next?#

Finito#

boxviewrb

onStart#

onFinish#

Sinatra Assets

onStart#

Sinatra AssetPack#

The Pipeline#

onFinish#

BoxView

onStart#

Upload a Document#

Create a Session#

Generate a Thumbnail#

onFinish#

Fragment Factories

onStart#

Fragment Generation#

New Instance#

onFinish#

Promises and More

onStart#

jQuery Deferreds#

Image Loading with jQuery Promises#

CJSX-Codemod #

Decaffeinate #

React-Codemod #

ESLint #