Why cleaner code?

1. Why cleaner code?

In this chapter, we'll see how we can use purrr to write cleaner code. But first things first, let's ask ourselves this question: why should we bother to write cleaner code in the first place?

2. Where's Waldo?

Let's have a look at this piece of code. Have you spotted the errors yet? In this code, there are two typos: one in the name of a column on the second line, and one in the function name on line 4 — also, the "Sepal.Length" column appears twice. Moreover, if we want to change the p.value threshold in the filter, we will have to do it four times using the current code. So, here are the two big issues with this code: first, it's harder to spot typos as there is a lot of repetition, and it's harder to interpret what's going on in each line - our eyes are more focused on what is similar than on what is changing.

3. Finding Waldo

Let's now have a look at this new piece of code. For now, don't focus on the functions used: we'll see them in more detail throughout this chapter. Just focus on the readability and the maintainability. It's much easier to interpret this code, and to maintain it: if we need to change something, for example, the p.value threshold, we will just have to do it once. Same goes for the na.action parameter, which defines the behavior of the lm() function if it en counters a missing value. That's something you should always aim for when you are writing code: write code so that when in the future you'll need to change one thing, you'll just have to do it once.

4. What is clean code?

So, let's review what makes code clean. First, it's light, in the sense that there should be no unnecessary code. Light code is easier to read: your eyes can more easily focus on the part of the code being executed if there is no repetition, rather than trying to read inside each repetition. As there is no repetition, it's also easier to interpret: one bit of code, and one bit only is used to do one specific task. In the end, this also helps you in the long run, as it is easier to maintain. Think about the moment when you will have to change something, such as fixing a bug or implementing a new feature, when using light and clean code; you just have to change things once.

5. compose()

The first function we will see is compose(), which, as its name suggests, is used to compose a new function from two other functions. compose() is a tidyverse adverb: it takes a series of functions and returns a new function. This newly created function can be called like any other function.

6. Composing cleaner code

As you can see, thanks to the compose() function, the code on the bottom of this slide is cleaner. It is easier to read and understand, as there are fewer repetitions. And it is easier to maintain it, because if you need to change the content of your pipeline, you only have to do it once, instead of having to change the four nested functions.

7. Let's practice!

Now let's try to write better code with compose().

This exercise is part of the course

Intermediate Functional Programming with purrr

IntermediateSkill Level

4.9+

Start Course for Free

Do lambda functions, mappers, and predicates sound scary to you? Fear no more! After refreshing your purrr memory, we will dive into functional programming 101, discover anonymous functions and predicates, and see how we can use them to clean and explore data.

Exercise 1: purrr basics - a refresher Exercise 2: Refreshing your purrr memory Exercise 3: Another purrr refresher Exercise 4: Introduction to mappers Exercise 5: Creating lambda functions Exercise 6: Lambda functions Exercise 7: Using mappers to clean up your data Exercise 8: Clean up your data with keep Exercise 9: Split up with keep() and discard()Exercise 10: Predicates Exercise 11: What is a predicate?Exercise 12: Exploring data with predicates

Ready to go deeper with functional programming and purrr? In this chapter, we'll discover the concept of functional programming, explore error handling using including safely() and possibly(), and introduce the function compact() for cleaning your code.

Exercise 1: Functional programming in R Exercise 2: Everything that happens is a function call Exercise 3: Identifying pure functions Exercise 4: Tools for functional programming in purrr Exercise 5: Safe iterations Exercise 6: Create a function Exercise 7: Using possibly()Exercise 8: A possibly() version of read_lines()Exercise 9: Everything in one call Exercise 10: Handling adverb results Exercise 11: Purrrfecting our function Exercise 12: Extracting status codes with GET()

In this chapter, we'll use purrr to write code that is clearer, cleaner, and easier to maintain. We'll learn how to write clean functions with compose() and negate(). We'll also use partial() to compose functions by "prefilling" arguments from existing functions. Lastly, we'll introduce list-columns, which are a convenient data structure that helps us write clean code using the Tidyverse.

Exercise 1: Why cleaner code?

Current Exercise

Exercise 2: How to write compose()Exercise 3: Back to the office Exercise 4: Building functions with compose() and negate()Exercise 5: Build a function Exercise 6: Count the NA Exercise 7: Prefilling functions Exercise 8: A content extractor Exercise 9: Another extractor Exercise 10: List columns Exercise 11: About list-columns Exercise 12: Create a list-column data.frame

We'll wrap up everything we know about purrr in a case study. Here, we'll use purrr to analyze data that has been scraped from Twitter. We'll use clean code to organize the data and then we'll identify Twitter influencers from the 2018 RStudio conference.

Exercise 1: Discovering the dataset Exercise 2: Playing with tweets, round 1 Exercise 3: Identify profiles Exercise 4: Extracting information from the dataset Exercise 5: Counting favorites Exercise 6: Extracting mentions Exercise 7: Manipulating URLs Exercise 8: Analyzing URLs Exercise 9: Playing with URLs Exercise 10: Identifying influencers Exercise 11: Splitting the dataset Exercise 12: We have a winner!Exercise 13: Congratulations!