R-Ladies chapters from the Netherlands are gathering forces to host online book clubs!
We are very excited to start with the book Advanced R by Hadley Wickham.
-
Highlight the key points on each topic of the book with a presentation.
-
Go together through the exercises.
-
Discuss and clarify doubts.
The events will be hosted every two weeks by different R-Ladies chapters, on Tuesdays at 6pm, via jitsi.
|
chapter |
title |
description |
speaker |
date |
hosted_by |
link |
|---|---|---|---|---|---|---|
|
2 |
Names and values |
Teaches you about an important distinction that you probably haven’t thought deeply about: the difference between an object and its name. Improving your mental model here will help you make better predictions about when R copies data and hence which basic operations are cheap and which are expensive |
Laurel Brehm |
2020-04-07 |
Nijmegen |
|
|
3 |
Vectors |
Dives into the details of vectors, helping you learn how the different types of vector fit together. You’ll also learn about attributes, which allow you to store arbitrary metadata, and form the basis for two of R’s object-oriented programming toolkits. |
Paloma Rojas |
2020-04-21 |
Rotterdam |
|
|
4 |
Subsetting |
Describes how to use subsetting to write clear, concise, and efficient R code. Understanding the fundamental components will allow you to solve new problems by combining the building blocks in novel ways. |
Martine Jansen |
2020-05-12 |
Den Bosch |
|
|
5 |
Control flow |
Presents tools of control flow that allow you to only execute code under certain conditions, or to repeatedly execute code with changing inputs. These include the important if and for constructs, as well as related tools like switch() and while. |
Margaux Sleckman |
2020-05-26 |
Amsterdam |
|
|
6 |
Functions |
Deals with functions, the most important building blocks of R code. You’ll learn exactly how they work, including the scoping rules, which govern how R looks up values from names. You’ll also learn more of the details behind lazy evaluation, and how you can control what happens when you exit a function. |
Josephine Daub |
2020-06-09 |
Nijmegen |
|
|
7 |
Environments |
Describes a data structure that is crucial for understanding how R works, but quite unimportant for data analysis: the environment. Environments are the data structure that binds names to values, and they power important tools like package namespaces. Unlike most programming languages, environments in R are “first class” which means that you can manipulate them just like other objects. |
Alejandra Hernandez |
2020-06-23 |
Utrecht |
|
|
8 |
Conditions |
Concludes the foundations of R with an exploration of “conditions”, the umbrella term used to describe errors, warnings, and messages. You’ve certainly encountered these before, so in this chapter you learn how to signal them appropriately in your own functions, and how to handle them when signalled elsewhere. |
Semiramis Castro |
2020-07-07 |
Rotterdam |
|
|
9 |
Functionals |
Shows you how to replace many for loops with functionals which are functions (like lapply()) that take another function as an argument. Functionals allow you to take a function that solves the problem for a single input and generalise it to handle any number of inputs. Functionals are by far and away the most important technique and you’ll use them all the time in data analysis. |
Martine Jansen |
2020-07-21 |
Den Bosch |
|
|
10 |
Function factories |
Introduces function factories: functions that create functions. Function factories are less commonly used than functionals, but can allow you to elegantly partition work between different parts of your code. |
Sarah Stole |
2020-08-04 |
Amsterdam |
|
|
11 |
Function operators |
Shows you how to create function operators: functions that take functions as input and produce functions as output. They are like adverbs, because they typically modify the operation of a function. |
Laurel Brehm |
2020-08-18 |
Nijmegen |
|
|
12 and 13 |
Base types and S3 |
Ch 12 introduces object-oriented programming. Ch 13 introduces S3, the only OO system used in the base and stats packages, and the most commonly used system in CRAN packages. S3 is very flexible, which means it allows you to do things that are quite ill-advised. This chapter will therefore teach you the conventions you should (almost) always follow. |
Alejandra Hernandez |
2020-09-01 |
Utrecht |
|
|
14 |
R6 |
This chapter describes the R6 OOP system. R6 has two special properties: It uses the encapsulated OOP paradigm, which means that methods belong to objects, not generics, and you call them like object$method(). R6 objects are mutable, which means that they are modified in place, and hence have reference semantics. |
Johanna Munoz |
2020-09-15 |
Rotterdam |
|
|
15 and 16 |
S4 and Trade-offs |
15: S4 provides a formal approach to functional OOP. The underlying ideas are similar to S3 (the topic of Chapter 13), but implementation is much stricter and makes use of specialised functions for creating classes (setClass()), generics (setGeneric()), and methods (setMethod()). Additionally, S4 provides both multiple inheritance (i.e. a class can have multiple parents) and multiple dispatch (i.e. method dispatch can use the class of multiple arguments). 116: Now that we know about the different types of classes, how to pick one? This chapter discusses. |
Martine Jansen |
2020-09-29 |
Den Bosch |
|
|
17 |
Big picture |
Compares these three main OO systems. By understanding the trade-offs of each system you can appreciate when to use one or the othe |
Janine Khuc |
2020-10-13 |
Amsterdam |
|
|
18 |
Expressions |
Shows that that all R code can be described as a tree. You’ll learn how to visualise these trees, how the rules of R’s grammar convert linear sequences of characters into these trees, and how to use recursive functions to work with code trees. |
Alejandra Hernandez |
2020-10-27 |
Utrecht |
|
|
19 |
Quasiquotation |
Presents tools from rlang that you can use to capture (quote) unevaluated function arguments. You’ll also learn about quasiquotation, which provides a set of techniques to unquote input to make it possible to easily generate new trees from code fragments. |
Paloma Rojas |
2020-11-10 |
Rotterdam |
|
|
20 |
Evaluation |
Moves on to evaluating captured code. Here you’ll learn about an important data structure, the quosure, which ensures correct evaluation by capturing both the code to evaluate, and the environment in which to evaluate it. This chapter will show you how to put all the pieces together to understand how NSE works in base R, and how to write functions that work like subset(). |
Pavitra Chakravarty |
2020-11-24 |
Den Bosch |
NA |
|
22 |
Debugging |
Talks about debugging, because finding the root cause of error can be extremely frustrating. Fortunately R has some great tools for debugging, and when they’re coupled with a solid strategy, you should be able to find the root cause for most problems rapidly and relatively painlessly. |
Alejandra Hernandez |
2020-12-08 |
Utrecht |
|
|
23 and 24 |
Measuring and Improving performance |
Focuses on measuring and how to improve performance |
Semiramis Castro |
2020-12-22 |
Rotterdam |
Sign-up to present a topic here
To join the event, click at the link on our Current agenda!
Looking forward to see you soon!
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent