DEV Community: Alex Manarpies

Android device debugging on Linux Mint: “error: insufficient permissions for device: udev requires plugdev group membership”

Alex Manarpies — Sun, 28 Apr 2019 13:58:13 +0000

As I rejoiced in the achievement of finally finding a Linux distro which plays well with my Dell XPS 13 (2019 edition, model 9380), I plugged in my Moto test device, intending to continue working on an Android app. Pressing the Run button promptly made Android Studio (3.4) do its compilation magic, but got stopped in its tracks rather quickly. An angry-looking error message awaited me:

error: insufficient permissions for device: udev requires plugdev group membership

Android Studio also left a note pointing me to their developer page on the subject. As I suspected, it seemed I had some configuration work left to get device debugging working on Linux. However, following Google’s instructions on setting up adb didn’t do much to resolve my problem. The part about adding yourself to the udev group is important, though, as it’s linked to the actual solution described in the next paragraph.

sudo usermod -aG plugdev $LOGNAME

An ill-timed dog walk (let’s just say I hadn’t expected to be caught in the middle of a downpour), and a few mildly frustrated Google searches later, I ran across a blog post from 2013 (!) on the subject of “Adding udev rules for USB debugging Android devices“, by Janos Gyerik.

I will not pretend to know why this extra configuration is required, but it describes looking up the device’s identifier and adding it to the aforementioned plugdev access group, so Android Studio can properly access the USB device.

And there you go, a working USB debugging connection to my Android device, thanks to some great advice from 2013!

Originally posted on jarroo.com

Unit Testing AWS Lambda Functions in Node.js

Alex Manarpies — Sun, 09 Dec 2018 15:18:12 +0000

Writing backend code - like web services or anything else really - with AWS Lambda functions is amazingly easy, in particular when you choose Node.js as your weapon of choice. The amount of code required to get going is so sparse, it's almost magical. However, as you build out your Lambda, complexity will quickly rear its head, and you'll soon feel the need to add some tests.

Unit testing is a part of any good developer's workflow, but I feel it's especially important when dealing with dynamically typed languages, like vanilla Javascript. Its loosely-typed nature makes development fast, but also makes for a certain degree of uncertainty when making changes, or while refactoring. Good test coverage can make up for this, and it can allow you to work faster. If you're able to mock your Lambda's dependencies, you'll be pretty confident that your successful unit test is representative of the eventual production code.

Dependency Injection

"Dependency Injection" is the somewhat intidimidating term used in software engineering to describe something quite simple:

Dependency injection is a programming technique that makes a class independent of its dependencies. It achieves that by decoupling the usage of an object from its creation.

It's most useful when applied in the context of unit testing because it enables you to mock dependencies that shouldn't be active during tests.

In Node.js Lambda functions, dependencies are imported using the require() function. It creates a constant in the function's scope, pointing to some outside code. By default, you'll do this at the top level of your Node.js file, effectively making the dependency globally accessible to said file. Consider this snippet, where we're importing the AWS SDK, and creating a new instance of the DynamoDB DocumentClient:

const AWS = require('aws-sdk')
const documentClient = new AWS.DynamoDB.DocumentClient()

What happens when you unit test code that imports the above dependency? In this case, your test will establish a live connection to DynamoDB and potentially start reading and writing data to it! While you could argue this is a test in and of itself, this situation is far from ideal. Each unit test invocation will

potentially incur costs
write data to a live database, possibly messing up its consistency
be slow

Richard Hyatt's Medium post from 2016 is still relevant today, as it describes how we can make dependency loading asynchronous and injectable by using the exports object to store and reference dependencies.

exports.deps = () => {
  const AWS = require('aws-sdk')
  const documentClient = new AWS.DynamoDB.DocumentClient()

  return Promise.resolve({
    dynamoBatchWrite: params => documentClient.batchWrite(params).promise()
  })
}

The actual dependency import is enclosed into the deps function scope, and is made asynchronous by wrapping the result dictionary in a Promise. This asynchronicity allows us to overwrite the deps function during tests, while leaving it as-is in production.

The production code will just await the dependencies at the top, after which you'll be able to access the fully constructed dependencies:

exports.handler = async event => {
  const deps = await exports.deps()
  ...
}

Now, for the test:

require('chai').should()
const lambda = require('../index')
const sinon = require('sinon')

describe('importOPML', () => {
  beforeEach('mock dependencies', () => {
    const mockWriter = sinon.mock()
    mockWriter.resolves({ UnprocessedItems: [] })

    lambda.deps = () => Promise.resolve({
      dynamoBatchWrite: mockWriter
    })
  })

  it('should succeed with empty opml', async () => {
    // Using lambda here, will call the version that uses the mocked DynamoDB writer.
  }
})

This happens to be a Chai test that uses Sinon for mocking, but the premise is the same. Before each test block is run, the beforeEach block is executed, which preps the lambda with the mock dependencies.

That's it. You're off to the races!

What's new in Swift 4.2.1?

Alex Manarpies — Sun, 02 Dec 2018 09:45:57 +0000

Yes! There appears to be such a thing, and it was silently shipped alongside Xcode 10's first point-release, 10.1. Contrary to major releases, Swift 4.2.1's release wasn't accompanied by a blog post, nor was its entry added to the Swift changelog. Is there a reason for this all this mystery, or is the 4.2.1 really just so insignificant?

Pierpaolo Frasa must've been wondering the same thing, based on his recent post on the Swift forums:

My mac wants me to upgrade to Xcode 10.1, which will include Swift 4.2.1.
However, I can't find any mention of that swift version either on the download page or in the changelog.

[...]

The list of resolved issues is rather short, with 8 compiler issues fixed, and just one problem resolved in the standard library. The highlights include:

A fix for ambiguous compilation error messages like “Command CompileSwiftSources failed with a nonzero exit code”
The Bundle class's init(for:) initializer now works consistently with Swift classes, not just Objective-C classes
Long file paths containing white space no longer cause build failures
A mutating method that returns Self on a value of protocol type can now successfully be invoked

Check out the "Swift Compiler" and "Swift Standard Library" sections in the Xcode release notes for a complete list of the changes, complete with code samples.

2 Interactive Resources for Brushing Up Your RegEx Knowledge

Alex Manarpies — Sun, 02 Dec 2018 08:39:58 +0000

For the longest time, regular expressions have remained something of an enigma to me. Despite the many, many learning opportunities, across various programming languages, my ignorance of their perplexing syntax usually directed to me toward implementing my own code-based algorithms instead. It's clear that most of the time, such roll-your-own solutions don't cut it performance-wise, and probably end up being just as obscure and difficult to decipher, weeks or months down the road.

During my recent endeavor to learn Python, the need for some sprinkles of RegEx quickly presented itself. This time around, I set out to apply myself, and at least master the basics. While clicking around on the web, in search of quality learning resources, I grew pleasantly surprised at the crop of interactive resources on the subject and would like to highlight two for you. They're a refreshing change from the selection of the many animal-toting books on the matter.

RegexOne.com

RegexOne.com is a delightful donation-supported website that guides you through the basics of regular expressions with a dozen (or so) lessons which are short, to the point, and each capped with an interactive input box. Exercises build on the previous ones to introduce each subsequent concept, highlighting the current match as you type. The little quizzes aren't too hard, and in case you get stuck, the solution is just a click away.

Once you've whizzed through the lessons, you can fall back on 5 language-specific guides:

C#
Javascript
Java
PHP
Python

RegEx101.com for on-the-fly testing and debugging

With your freshly harnessed knowledge, hop over to RegEx101.com, an online development, and debugging suite. Your test string will light up with an abundance of helpful widgets, in addition to highlighting matches:

full match information
capture groups
English, context-sensitive translation of what the RegEx statement means
a quick reference box
a code generator for 9 languages (Javascript, PHP, Python, C#, Java, Ruby, and Rust)
a means for sharing and storing your work

In not much more than an hour - with the help of these two free resources - I was able to craft an expression that succinctly extracted the information I needed, without resorting to my own obscure and undoubtedly inefficient one-off algorithm.