• Karl Ho is:

  • Professor of Instruction at University of Texas at Dallas (UTD) School of Economic, Political and Policy Sciences (EPPS)
  • Co-founder of the UTD Social Data Analytics and Research program (SDAR)
  • Founder of DataGeneration.org
  • Author of Data Programming
  • Co-Principal Investigator of the Hong Kong Election Study project
  • Website: karlho.com (talks, lecture, publications)

Speaker bio.

Overview:

• Programming is a practice of using programming language to design, perform and evaluate tasks using a computer.  These tasks include:
  • Computation
  • Data collection
  • Data management
  • Data visualization
  • Data modeling
• In this course, we focus on data programming, which emphasizes programs dealing with and evolving with data.

What is programming?

Data programming

}

Why learning programming Languages?

- Maribel Fernandez 2014

DRY – Don’t Repeat Yourself

Write a function!

Function example

# Create preload function
# Check if a package is installed.
# If yes, load the library
# If no, install package and load the library

preload<-function(x)
{
  x <- as.character(x)
  if (!require(x,character.only=TRUE))
  {
    install.packages(pkgs=x,  repos="http://cran.r-project.org")
    require(x,character.only=TRUE)
  }
}

Why learning programming?

What is R?

It is:

• ​Large, probably one of the largest based on the user-written add-ons/procedures

• Object-oriented

• Interactive

• Multiplatform: Windows, Mac, Linux

R Programming Basics

• Use vectorization: Vectorization is a technique for performing operations on entire vectors or matrices at once, rather than looping through each element. This can significantly speed up R code.

Tips for optimizing R code for better performance

• Use efficient data structures: R has several data structures, such as data frames and lists, that are optimized for different types of operations. Choosing the right data structure for a given task can improve performance.

Tips for optimizing R code for better performance

• Avoid unnecessary copying: R creates copies of objects when they are modified, which can be slow for large objects. Using in-place modification or avoiding modification altogether can improve performance.

Tips for optimizing R code for better performance

• Use parallel processing: R has several packages, such as parallel and foreach, that allow for parallel processing. This can speed up computations on multi-core machines.

Tips for optimizing R code for better performance

• Use memoization: Memoization is a technique for caching the results of expensive computations so that they can be reused later. This can speed up computations that are repeated frequently.

Tips for optimizing R code for better performance

• Use Rcpp: Rcpp is a package that allows for integration of C++ code with R. This can significantly improve performance for computationally intensive tasks.

Tips for optimizing R code for better performance

• Core/processor

  • A core is a general term for either a single processor on your own computer (technically you only have one processor, but a modern processor like the i7 or M2 can have multiple cores - hence the term) or a single machine in a cluster network.

• Cluster

  • A cluster is a collection of objecting capable of hosting cores, either a network or just the collection of cores 

• Process

  • A process is a single running version of R (or more generally any program). Each core runs a single process.

• Node: A node refers to a physical box or server in a cluster. It typically consists of one or more CPUs, memory, storage, and other components. Nodes are connected to each other through a network and can communicate with each other to perform parallel computing tasks.

• User time:

  • the amount of CPU time spent by the current process (i.e., the current R session) executing the expression. It measures the time spent executing user-level code, such as loops, conditionals, and function calls.

• System time:

  • the amount of CPU time spent by the kernel (the operating system) on behalf of the current process executing the expression. It measures the time spent executing system-level code, such as opening files, doing input or output, starting other processes, and looking at the system clock.

• Elapsed time:

  • the wall clock time taken to execute the expression. It measures the total time taken to execute the expression, including time spent waiting for input or output, time spent waiting for other processes to complete, and time spent waiting for the CPU to become available.

• Socket

  • socket launches a new version of R on each core. Technically this connection is done via networking (e.g. the same as connecting to a remote server), but the connection is happening all on local computer.

  • works on all platforms including Windows and MacOS

  • Pro:

    • Each process on each node is unique so it can’t cross-contaminate.

  • Con:

    • Each process is unique so it will be slower

    • Package loading need to be done in each process separately. Variables defined on main version of R do not exist on each core unless explicitly placed there.

    • More complicated to implement.

• Forking
  • Forking copies the entire current version of R and moves it to a new core.
  • Only for MacOS and Linux
  • Pro:
    • Faster than sockets.
    • Because it copies the existing version of R, your entire workspace exists in each process.
    • Easy to implement.
  • Con:
    • Because processes are duplicates, it can cause issues specifically with random number generation (which should usually be handled by parallel in the background) or when running in a GUI (such as RStudio). 

Beware of bugs in the above code; I have only proved it correct, not tried it."

 

- Donald Knuth, author of The Art of Computer Programming