An old idea

Found this old semi-serious idea of mine on one of my old web sites via The Wayback Machine. It was originally intended as sarcasm, but it wasn’t a half-bad idea! End users really should be able to present software vendors with a “license agreement” of their own that protects end-user rights. If any creative lawyer out there is interested in shoring this up and making it into a real thing, please let me know 🙂


SOFTWARE VENDOR LICENSE AGREEMENT

This SVLA is a legal agreement between you (the software vendor [“Vendor”]) and the end user (“User”) of a software product (“Software”) purchased from you by the User. This SVLA is an amendment of any contracts, disclaimers and agreements which can only be fully read by the User after purchasing or using the Software. These contracts, disclaimers, and agreements will be collectively referred to as the End User License Agreement (“EULA”). In areas where this SVLA conflicts with the EULA, this SVLA shall supersede any conflicting statements in the EULA. You must accept this Agreement before the User will be bound by the terms of the EULA. If you do not accept the terms of this Agreement, the EULA is immediately void and the User is not bound by any terms of the EULA.

USER RIGHTS

The User reserves the right to use, not use, install, not install, uninstall, and remove any component, module, file, or other portion (“Component”) of the Software. This includes, without limitation, any type of “Spyware” or other component that compromises the User’s privacy or otherwise negatively (according to the User’s judgment) affects the User’s use of legitimately purchased Software or the system on which it is installed.

The User reserves the right to to prevent or limit, without restriction, the Software’s use of any computer resource, including memory, disk space, network connectivity, processor and files present on the system.

The User reserves the right to continued dependable and error-free operation of the operating system (“System”) on which the Software will be installed. The User reserves the right to continued dependable and error-free operation of all other installed programs on the System.

The User reserves the right to demand that the Software will function as advertised. If the Software fails to function as advertised or fails to function in an error-free, robust manner, the User reserves the right to return the Software to the Vendor for a full refund of the User’s final after-tax purchase price.

If the Software is found to contain errors that prevent or limit its advertised function (“Errors”), and the software vendor is unable or unwilling to provide a refund or correct such Errors in a timely manner, the User reserves the right to debug, work around, or correct such Errors without further authorization from the Vendor, even if these work-arounds or bugfixes require modifications be made to some or all of the Software’s Components. Such modifications may require that the User view and make changes to the Software’s binary code, either in its raw form or a machine-translated form the User can use more conveniently. The content of such software-improving modifications are the sole property of the User and may not be copied or used by the Vendor without the express consent of the User. [Clarification: The User does not gain copyright ownership of the Software Components modified, but simply maintains the rights to the modifications themselves. This clause merely prevents instances of the Vendor profiting from the User’s hard work and expertise without consent, and supersedes EULA clauses giving the Vendor rights to such modifications.] The User agrees that these modifications are for his or her own personal use, and may not sell modified copies of the Software for a profit. The User may, however, instruct others in performing the modifications necessary to improve the Software. The User agrees to hold the Vendor harmless for any damage that directly results from modifications the User has made to the Software.

As in the case of Errors present in the Software, the User reserves the right to make improvements to the Software for his or her own personal use, using methods set forth in the previous section. Again, the content of these Improvements themselves are the property of the User, and the User agrees to hold the Vendor harmless for damage directly resulting from the modifications made. The User further agrees not to distribute the modified software or profit from the distribution of the modifications/improvements.

The Vendor agrees that the contents of the User’s computing facilities, including data stored in memory or on disk, environment variables, user habits and system geometry are considered private and understands that the system on which the Software is installed may contain proprietary information. The Vendor agrees that any such private information may not be transmitted in whole or in part without the prior express consent of the User. The User must be informed in clear, unambiguous wording of any data-transmission capabilities that may compromise the privacy of any User data, and must be allowed to explicitly allow or disallow the transmission, BEFORE any transmission takes place. This information must be explicitly stated independently of the EULA or any other textual materials that may diminish the force and effect of this information. [Clarification: The Vendor understands that “burying” such information in fine print, help documents or other materials does not satisfy the Vendor’s obligation to disclose this information.] The User reserves the right to proactively enforce this privacy. For the purposes of the SVLA, “system geometry” refers to information about the features and capabilities of the system and the devices connected to it, including information about the size of the hard drive, amount of memory, processor speed, size and speed of local networks, and information about attached peripherals.

Upon reasonable suspicion that the functionality or purpose of the Software have been misrepresented, the User reserves the right to seek outside analysis of the Software by qualified professionals. To this end, the User reserves the right to disclose information necessary to evaluate such claims to an appropriate party or parties qualified to make such an evaluation. This disclosure may include descriptions of the Software’s behavior, promotional materials, packaging, or some or all of the Software itself. The User reserves the right to disclose the results of a professional analysis of the Software, including information relating to false claims, and provide evidence of such claims. The User reserves the right to remain immune to prosecution by the Vendor under section 1201 of the United States federal law known as the Digital Millennium Copyright Act (DMCA).

If it has been determined that the Vendor has engaged in false claims or other wrongdoing relating to the operation of the Software, the User reserves the right to disclose portions of the Software necessary to substantiate allegations of wrongdoing, even if such disclosures contain information considered private or proprietary by the Vendor. This clause specifically targets “censorware” and Software products of like type.

The User reserves the right to be fully informed of any content-protection or copy-restriction mechanisms employed by the Software before purchasing the Software. In the event the Vendor violates this User right, the Vendor must provide an option for the User to return the software for a refund equal to the User’s full after-tax purchase price of the software.

USER RESPONSIBILITIES

This SVLA applies only to legally purchased commercial software. It does not apply to Freeware or unpurchased Shareware trial products.

The User agrees that he or she has legally purchased the Software. The SVLA is not a piracy license and does not entitle the User to violate applicable copyright laws.

The User agrees to make reasonable efforts to protect his or her copies of the Software and license codes, if any, from theft and improper use. The User agrees not to illegally distribute copies of the Software or facilitate the distribution of the Software. The User understands that the unauthorized duplication of the Software is a crime and is punishable by law.

If a legitimate copy of the Software comes with a Certificate of Authenticity or other proof of ownership, the User agrees to present this proof of ownership to the Vendor as necessary to receive technical support, Software updates, or other services provided by the Vendor. If the Software is not accompanied by a Certificate of Authenticity or other proof of purchase, the User shall present the original Media, packaging, or software license codes, as required by the Vendor, to indicate proof of ownership.

The User understands that the Software may contain private or proprietary information, including proprietary algorithms protected by copyright and patents.

The User understands that during the course of installing, modifying or using the Software, he or she may be exposed to proprietary algorithms, and agrees that this information is the property of the Software Vendor and may not be disclosed by the User or used for other purposes, except as permitted by law, without the express consent of the Vendor. This clause specifically excludes non-executable data files containing materials not owned by the Vendor and those materials and situations covered by the “censorware clause”.

The User agrees that his or her eligibility for a Refund is conditional on his or her ceasing use of the Software and removing all Components from the system. The User is required to remove all copies of the Software from the system and may be required to return or destroy the original Media and proof of ownership, if applicable, upon receiving the Refund.

Posted in Uncategorized | Tagged , , | Leave a comment

How to configure Windows to auto-logon and auto-lock at startup

To get an app to run automatically when you logon, you can drop its shortcut into the “Startup” folder inside your Start menu, or you can configure it (if the app provides such a setting, as many apps do) to automatically run “at startup”. But the word startup is misleading, because these will only run at logon, not as soon as the system starts up. If you’re not around your PC when it starts up — say, following a Windows Update mandated auto-restart or a power outage — then you won’t be there to logon, and anything you wanted to remain automatically running won’t be running.

Some apps, such as the Oculus client or the Folding@Home client, do not run as services and can only run inside of a logged-on user session. You want them to always be running whenever the system is on, but Windows doesn’t provide any clear way to do this without you logging on first.

Solving this is easier than you might think.

1. Configure Windows to auto-logon your user account.

Download and run SysInternals Autologon. You can easily use it to configure your Windows to auto-logon using your user account. It’s self-explanatory.

2. Configure your user account to auto-lock the desktop after logging on.

This part requires some minor registry hacking and/or programming trickery. Fortunately, I’ve already written a simple shell script to do this for you! Download it here, extract the ZIPped contents to wherever, and then open a Command Prompt to that location, and run the script. If you ever need to disable autolock, just run autolock disable from inside the Command Prompt.

Posted in Uncategorized | Leave a comment

Common cause/effect fallacies

XY problems are one symptom of the all-too-common human tendency to incorrectly assess cause/effect relationships.  Correlation does not equal causation, as the aphorism goes.  And yet, even very smart people, who embrace such advice and try their best to mindfully apply it, still often fall victim to incorrect conclusions about cause/effect relationships.

Because I see this kind of thing all the time in my work as a software engineer, I’ve decided to assemble a running list of them here.  The intent of this list is to help my fellow engineers gain a little more self-awareness, as well as to help remind myself of these things, to help us all become more effective at what we do.

  1. I changed X, and it seemed to resolve problem Y; therefore, X caused Y.  (Counterexample: I drove my car to a colder climate, and it seemed to prevent my car’s engine from overheating; therefore, the warm climate back home was causing my engine to overheat.  But in fact, the engine has an actual problem that is just being masked now by the colder climate.)
  2. I changed X, but it didn’t seem to resolve problem Y; therefore, there was nothing wrong with X.  (Counterexample: I put new batteries in my remote, but the remote still didn’t work; therefore, the old batteries must have been fine.  But in fact, the batteries were dead in addition to the remote being broken.)
  3. I didn’t change X, and problem Y mysteriously went away; therefore, X did not cause Y.  (Counterexample: I didn’t touch the thermostat, and the last few days the temperature inside the house has been just fine again; therefore, the thermostat wasn’t the problem.  But in fact, the thermostat has been behaving intermittently for a while, randomly working at some times but not others.)
  4. I didn’t change X, and problem Y remains; therefore, X must be causing Y.  (Counterexample: It’s been ages since I put new tires on my car, and it’s been riding rough for a while; I must need new tires!  But in fact, the car is riding rough because the suspension is shot.)
  5. I did X and got result Y; therefore, everyone who does X will also get result Y.  (Counterexample: That program works fine on my computer; if it’s not working on yours, you must be doing something wrong!  But in fact, the other person’s computer has a failing hard drive.)
  6. I did X and got result Y; therefore, whenever I do X again, I will still get result Y.  (Counterexample: I used my ATM card to withdraw $100 today; I’m going to do the same thing tomorrow.  But in fact, today was the last day of the month, and your ATM card expires this month, so your card won’t work tomorrow.)

 

 

Posted in Uncategorized | Leave a comment

How to use Adobe Photoshop to create photos with TWICE the physical pixel resolution of your smartphone camera

Occasionally, I’ll need to capture a digital photo of something at a resolution that is higher than my iPhone camera can physically do.  (Example: photographing something to upload to a web sites that will reprint my photo on a giant wall canvas, banner, etc.)  Unfortunately, decent standalone digital cameras that greatly exceed the iPhone camera’s 12-megapixel resolution are at least several hundred dollars!  That’s a lot to spend on something I’ll only use once in a blue moon!  So instead, I use the following process and some Adobe Photoshop software magic to produce photos with twice the resolution of my iPhone camera.

  1. Take a set ~20 nearly-identical photos.  On my iPhone, I do this using the camera’s “burst mode” feature, but I’m sure something similar probably exists on Android phone as well.  I zoom the camera all the way out, point it out my subject, and then hold as still as I can (but without using a tripod) while I press and hold down the snapshot button and let it take a series of ~20 photos.  It is important to NOT use a tripod or any other kind of stabilizing device, because the goal is to let the natural subtle movements that we all make when trying to hold still create tiny little random variations in position with each photo.  This means each photo will align the “reality” of whatever you’re photographing slightly differently against the camera’s physical pixel matrix.  After taking the burst of photos, they will appear in the Photos app as a single photo… you have to tap on that photo to view it, then choose Select…, and manually select/check every single photo in the list before tapping Done.  This will cause all of the photos in the burst to appear in your Photos app as separate photos.  Those are the photos I’ll transfer to my PC and open in Adobe Photoshop.
  2. Open all of the photos as layers of a single project in Photoshop.  You can do this by going to File > Scripts > Load Files into Stack… and manually selecting all of the files.  Be sure to leave Automatically Attempt to Align Source Images and Create Smart Object after Loading Layers both unchecked.
  3. Scale all of the images up by a factor of 4x along each axis.  You can do this by going to Image > Image Size… and specifying 400% for both the width and height.  Important: make sure to select Nearest Neighbor as the Resample type to avoid performing any smoothing.  We want to keep the original blocky pixels and just make them bigger.  By doing this, we are effectively subdividing each original camera pixel into a 4×4 grid of 16 subpixels, which will enable the next step to perform the real magic.  This is the key step that many other instructional guides I’ve found online are missing — and without it, the process will not yield the desired result!
  4. Automatically align all the images.  You can do this by multi-selecting all of the layers in the Layers pane, then going to Edit > Auto-Align Layers….  Just use the default setting of Automatic on the resulting dialog, and leave all other options unchecked.  This is where the magic happens, because Photoshop’s smart algorithm will adjust position, size, rotation, etc of every layer so that they all line up… and we have given Photoshop plenty of sub-pixel granularity to work with.
  5. Combine all the images into a single image.  You can do this my multi-selecting all of the layers in the Layers pane, then going to Layer > Smart Objects > Convert to Smart Object, followed by going to Layer > Smart Objects > Stack Mode > Mean, then going to Layer > Flatten Image.
  6. Scale the combined image back down to 50% along each axis.  You can do this by going to Image > Image Size… and specifying 50% for both the width and the height.  Important: make sure to select Bicubic Sharper (reduction) as the Resample type.
  7. Now save the final image.  Go to File > Save As… and save the final image to the format of your choice.

This process yields an image that is twice the physical camera resolution along each axis, with the missing details filled in by the sub-pixel variations between the original images that were created by your natural subtle movements.  It’s not quite as good as a true quadruple-megapixel camera, but it’s in the ballpark, and certainly much better than your camera’s physical resolution.

NOTE: There are some apps in the iPhone’s App Store, such as Atom Camera, which claim to produce double-resolution images using this technique.  Unfortunately, my analysis has shown that they do not produce photos that are any clearer or higher resolution than the built-in Camera app produces.  In short, they don’t work.

Example

Normal photo

Double-resolution photo

Zoomed-in comparison (left half = normal, right half = double-res):comparison

Posted in Uncategorized | Leave a comment

Why the Anbernic RG350 is a total waste of your time and money

The hardware itself is fine (even if disappointingly under-powered; it still can’t even run Sega 32X games at acceptable speeds, and many less-demanding emulators still exhibit noticeable audio cut-outs and framerate drops).  No, the real problems are the correspondingly awful documentation, support, and software.

For starters, the RG350 includes almost no useful documentation, and it’s nearly impossible to track down any information about who manufactures the device, who makes the software for it, or how to obtain software updates.  Apparently “Anbernic” is the manufacturer, but good luck finding any web site or other information about them in order to report bugs or get support.  And this is an open-source Linux-based device, so the manufacturer apparently doesn’t even make most (or any?) of the software for it.  The best I’ve been able to find is a very amateur-looking web site, an only somewhat better-looking wiki, a totally undocumented file server, and a YouTube video that provides misleading instructions about how to update the firmware (hint: you don’t actually have to remove or replace the internal microSD card).

Secondly, if (when) you encounter bugs in the software, it’s totally non-obvious where (or to whom) to file bug reports.  I spent an hour manually tracking down some GitHub repositories that are apparently the correct ones for some different pieces of the system software and a few of the emulators, but not all of them have issue trackers enabled, and the few that do have zero issues in their issue trackers.  Given the lack of clarity or direction around this, I’ve just started filing all software issue I’ve run into in this issue tracker.

Thirdly, there are LOTS of major bugs and usability issues with the software.  You can look in that issue tracker I linked to see just the ones I found in my first couple hours trying out the device.  The docs are misleading.  Some of the emulators barely work at all. Some of them don’t allow you to remap buttons into any usable configuration because their button mapping settings are totally busted.  Some of them provide no way to point them to the folder on the external microSD card containing your ROMs.  Some of them lack very basic and fundamental features.  No, you will not be having the nice fully-featured high-performance emulation experience that this device (or the early reviews of it) promised.

The bottom line is that the Anbernic RG350 is a highly unpolished amateur-hour project cobbled together by an international team of hobbyists (some of whom are Chinese and completely English-illiterate), not a refined or supported product backed by an actual company.  And therein lies the entire problem.  Unless you want to spend hours of your life screwing around with abysmally buggy software and trying to get things at least partially working, skip this device and look for something else.  From everything I’ve read and seen, you’re probably better off just buying a used PSVita or Switch and hacking it so it can run emulators — because at least then, after you’ve invested your time in all that DIY pain, you’ve got yourself a piece of hardware with some acceptable horsepower.

Posted in Uncategorized | Leave a comment

Preventing unintentional use of Unintentional Programming

In my last blog post, I introduced the concept of Unintentional Programming (UP). While written as a tongue-in-cheek parody of Intentional Programming, it’s a very real and frequently-encountered phenomenon.  Obviously, no good software engineer intends to practice UP — yet somehow, we still sometimes manage to write code that looks like the result of UP.  How does that happen, and what can we do to prevent it?

To answer those questions, I started by looking for trends in both “intentional” and unintentional” code I’ve seen.  (I use “intentional” to describe code which makes obvious both the problem it tries to solve and the way it tries to solve it.)  Here are some of my most noteworthy observations:

  • Otherwise bad code may still be highly intentional and thus easy to predictably fix and mentally verify.
  • Of all possible types of bad code, unintentional code is the absolute worst as it defies maintainability itself.
  • Unintentional code often results from the compounded accumulation of minimal-change fixes (or misguided spot fixes) to a poorly-understood or already-overly-complicated area.
  • Unintentional code often results from an incomplete or incorrect root cause analysis.
  • Intentional code tends to naturally fall out from clearly and accurately understanding the problem.
  • In an event-driven desktop application, one extremely common manifestation of UP is needlessly repeated identical executions of a potentially-expensive event handler.
  • Unintentional code often results from a temporary scaffolding or workaround accidentally becoming permanent.
  • Every developer tends to assume their intentions will be obvious to any other developer; it’s just a common pitfall of human psychology that nobody is immune to.
  • More liberal usage of asserts could have surfaced many instances of unintentional code earlier, but reliance upon them isn’t enough, since the developer has to anticipate what to assert against, and unintentional code by definition works for reasons unexpected by the developer.
  • Unintentional code slips through quality gates and into released software because it seemed to be working, so nobody ever thought to question what it was actually doing or how it was arriving at its results.
  • Testing (of any kind, including manual) can never surface all unintentional code, because even the most creative tests only verify that the product’s results are correct; testing cannot explain how the product arrived at a correct result.

Knowing these things, we can begin to dream up ways to prevent Unintentional Programming.  Here are some things we could try:

  • Engineering teams need to aggressively “shine a light” on “spooky” code areas that (almost) nobody understands.  Allocate time and people to efforts such as refactoring and adding true unit tests.  Do group readings/refactorings of spooky code so engineers can leverage each other’s insights and ideas to come to an understanding about how the code works and massage it into a more self-evident form.
  • Apply the “5 Whys” method of root-cause analysis to all proposed code changes, especially bug fixes, to ensure we’re always changing and fixing the right things for the right reasons.
  • Require at least one other engineer to build and step through any proposed change before calling it good.  It’s also a good idea to explicitly name the individual who performed that step in the change description, so that anyone looking through change history has one more person they know they can ask about that change.
  • If code makes an assumption, it either needs to gracefully handle any violation of that assumption, or assert that the assumption is true.  Asserts help catch problems before release.
  • Engineers should be stepping through the code in the debugger for common/core usage scenarios as part of every release’s manual test pass.  This will add confidence that the code is still working the way it’s expected to work under the hood, in a way that can’t necessarily be caught by unit tests, integration tests, UI automation tests, or dogfooding.
Posted in Uncategorized | Leave a comment

Unintentional Programming

In computer programming, Unintentional Programming (UP) is a programming paradigm inspired by the old adages, “Even a stopped clock gives the right time twice a day” and “If it ain’t broke, don’t fix it.”   It is a method for writing source code that happens to produce apparently-correct results upon cursory inspection, but without arriving at those results through any intentional, correct, sensible, or predictable internal operation.  By not thinking through all possible states, adding non-obvious dependencies on untested assumptions, not stepping through program execution, and creating needlessly convoluted workarounds to simple problems, the programmer greatly increases the probability their program will accidentally produce superficially correct results for at least some contexts.

Because software developed using Unintentional Programming arrives at correct results through sequences, states, and inputs never imagined or intended by the programmer, such software is incredibly difficult to maintain or improve.  The extreme disconnect between internal program operation and external results means that any change made to the source code can produce disastrously unexpected results.  Identifying why the program happens to produce correct results in some cases is just as difficult as identifying why it happens to produce incorrect results in other cases.  The conditions and sequence of operations that lead the program to produce incorrect results are so convoluted and difficult for the human mind to comprehend that the program’s behavior is, for all practical purposes, non-deterministic.

Due to its unpredictability, source code developed via Unintentional Programming can be frustrating for all members of an engineering team to work with.  For example, any attempt to replace some portion of the source code with new code that intentionally arrives at correct results will inevitably result in “breaking” cases that happened to produce correct results for the wrong reasons before the change, but which now produce incorrect results for the right reasons, frustrating everyone who thought it was working just fine before the change, naturally motivating them to fault the programmer who made the change rather than the unintentional nature of the old code.  Developers tasked with gradually transforming an existing large body of UP source code into software that behaves intentionally, sensibly, predictably, and correctly, face higher rates of nervous breakdown and ulcerative colitis than do their peers stranded inside underground bunkers on eerily magnetic tropical islands following airplane crashes.

Posted in Uncategorized | Leave a comment

WIN+F can go WIN+FUCK itself

Some recent Windows 10 update introduced this stupid new “Feedback Hub” thing that gets triggered every time I hit WIN+F.  This is supremely obnoxious because I often do remote development on a Mac over VNC from my Windows 10 PC, and WIN+F is the key combination used to invoke the “Find” dialog in most Mac apps when operating a Mac using a PC keyboard.  So at least half the time now, when I’m in a full-screen remote desktop (VNC) session to my Mac and I hit WIN+F to search for some text, I’m ripped completely out of my remote session by Windows 10 and presented with the god-damned-mother-fucking-Feedback-Hub-yet-again!  Microsoft, get off your collective asses and at least provide an option to DISABLE THE WIN+F SHORTCUT KEY FOR INVOKING FEEDBACK HUB!!  And before anyone asks: yes, I already sent Microsoft this feedback using the fucking Feedback Hub!  *Picard*facepalm*

Posted in Uncategorized | Leave a comment

Fix for SMSL M6 DAC losing USB sync and going silent due to static discharge when you touch it

Received my SMSL M6 DAC today, and it’s everything I’d hoped — except for one nagging problem: about half the time that I’d reach over to adjust the volume, the unit would stop producing sound and the PC would seem to think the device was disconnected.  Sometimes it would even cause all the other USB devices connected to the same hub to reboot themselves! Some online sleuthing and local elimination-of-factors revealed this to be a simple design problem: there is no solid ground connection between the shield of the USB jack and the metal case. It was pretty simple to take the unit apart, solder a grounding wire to the USB shielding inside the unit, and then loop the bare end of that wire around one of the screws when reassembling the case. Problem solved! It just sucks that such a simple thing should plague an otherwise excellent product.

Posted in Uncategorized | 1 Comment

Not all DACs are created equal

One of my many hobbies, born of necessity due to playing in my own band, is audio recording and engineering.  As such, I’ve spent a good chunk of change on decent-quality entry-level audio recording and playback gear, and I’ve burned hundreds of hours at my home PC working on mixes using said gear.  Yet it seems there’s always a lesson left to be learned the hard way and another better piece of gear to purchase.

I’m not an audiophile, but I am a musician with a good ear and a BS in Electrical Engineering.  I generally understand what goes into making, manipulating, and reproducing sound, and I’ve begun to see the relationship between certain traits of audio equipment and the resulting sound.  One thing that annoys me about many self-proclaimed audiophiles is that they have no real engineering or music-making background, so while they can sometimes hear that something sounds better (while at other times simply *thinking* something sounds better due to other factors such as brand name or price), they suck at explaining to the layperson exactly why one piece of gear sounds better than another.  I’ve often noticed audiophiles using terms like “sound stage” and “resolution” when discussing the ability of an audio playback device to respond rapidly and accurately to very low-volume and/or high-frequency non-primary wave forms.  Generally speaking, the higher the quality of an audio playback device, the better it is at reproducing such wave forms, and the more indescribably detailed and clear the music will seem as a result.  If you’ve never heard the difference, it’s difficult to explain, but allow me to try: if the earbuds included with your smartphone are like looking through a foggy slightly-out-of-focus window, then the real high-end-audiophile-grade stuff costing tens of thousands of dollars and typically used by real recording/mastering studios is like completely removing that window entirely and replacing your eyeballs with Hubble Space Telescopes.

I learned a few years ago the value of a good DAC + headphone amplifier (like my FiiO Andes e07k) to drive studio-quality earphones (like my Audio Technica ATH-M50s) or earbuds (like my Ultimate Ears UE900s) for both casual listening and mixing/production work.  While the amp helps drive more power-hungry earphones, the real magic lies in the DAC, which is of much higher quality than the headphone or line-out jack found built into any PC or laptop.  With entry-level “audiophile” earphones or earbuds, it’s very easy to hear the difference: bad DACs make the music sound flat, lifeless, and muddy, while good DACs make the music sound deep, sparkly, and clear.  In fact, if you’re doing mixing/production work, having a high-quality DAC is downright necessary, because otherwise you just can’t hear your own work accurately.  Using a bad DAC to mix or produce audio is like trying to refine a photo in Adobe Photoshop on a fuzzy black-and-white television.

One other piece of gear I own is a Focusrite Scarlett 18i6 USB audio interface.  It’s meant to be an all-in-one digital interface for both solid-quality recording and playback at high bitrates, so I’ve used it for ages as the primary audio device on my main PC.  It always worked admirably for recording with my laptop, so I naturally assumed the playback side would be equally strong… but I was WRONG!

I’ve been working on some mixes, struggling to get them sounding clear across a range of different playback systems (smart phones, car stereos, Bluetooth speakers, PA speakers, etc).  I thought I had the mix balanced just right, ran a render to raw WAV files, and then settled in with my iPad Air 2 and UE900s to give them a sanity-check… and was shocked to hear how ear-piercingly loud the cymbals were and how horribly muffled the guitar was, relative to what I’d spent hours working on.  I plugged the UE900s into my Scarlett 18i6 on the PC and pulled up the exact same WAV files — dull, bland, lifeless, with none of the details I’d noticed while listening on my iPad.  I swapped out the Scarlett 18i6 for my FiiO e07k (with bass/treble set flat) on my PC and pressed Play again — and it sprung to life, sounding almost exactly like what I’d heard out of my iPad.  I plugged my reference monitors into my FiiO e07k and heard the same details I’d heard out of it through my UE900s.  Using the FiiO e07k, I was easily able to correct my mix and even improve it well beyond what I’d thought was possible.

So, lesson #1: the playback DAC in the Scarlett isn’t very good.  And lesson #2: the DACs built into the iPad Air 2, iPad Pro 9.7″, and iPhone 6S Plus all sound quite respectable.

Of course, the FiiO e07k isn’t even the world’s greatest DAC; according to audiophile reviews, it falls somewhere in the medium-low end of the quality spectrum.  The FiiO is intended for portability anyway, and I needed a better permanent solution for my desktop PC, so I did a bit of research and ordered an SMSL M6.  It should be a slight step up in sound quality in a nice desktop-suitable form factor.

 

Posted in Uncategorized | Leave a comment