Leanne Dong leannejdong

Computer code is a series of executed statements. Frequently, these statements are executed one at a time. If one part of your code takes a long time to run, the rest of your code won't run until that part is finished.

However, this isn't how it has to be. We can often make the exact same code go much faster through parallelization, which is simply running different parts of the computer code simaltaneously.

Asynchronous Code

The first example of this is asynchronous code. The idea here is that many times you do things like send a call to another computer, perhaps over the internet, using an API. Normally, code then has to simply wait for the other computer to give it a response over the API. But asynchronous code can simply keep on going and then the API call returns later.

This makes code harder to reason about and handle because you don't know when the API call will return or what your code will be like when it returns, but it makes your code faster because you don't have to wait arou

Step 0 - Installing the XCode Development tools

Paste the following in your terminal, then press Enter and follow any prompts:

xcode-select --install

Step 1 - Install `homebrew`

My Arch Linux Setup Guide

This guide assumes the drive has already been partitioned and the EFI bootloader is already in place. I'll include these detailed steps the next time I need to do it. As I'm writing up these steps, I'm performing them on a machine that's already had it done, and I can't spend the time to start from scratch this time.

Arch Installation

Start with a bootable thumb drive that includes the latest version

Building TensorFlow from source (TF 2.3.0, Ubuntu 20.04)

Why build from source?

The official instructions on installing TensorFlow are here: https://www.tensorflow.org/install. If you want to install TensorFlow just using pip, you are running a supported Ubuntu LTS distribution, and you're happy to install the respective tested CUDA versions (which often are outdated), by all means go ahead. A good alternative may be to run a Docker image.

I am usually unhappy with installing what in effect are pre-built binaries. These binaries are often not compatible with the Ubuntu version I am running, the CUDA version that I have installed, and so on. Furthermore, they may be slower than binaries optimized for the target architecture, since certain instructions are not being used (e.g. AVX2, FMA).

So installing TensorFlow from source becomes a necessity. The official instructions on building TensorFlow from source are here: ht

git + overleaf + github

Setup

Connect Overleaf and your local repo

Make a new project on Overleaf.
In the share menu, copy the link from "Clone with git"
On your computer:
- use cd to navigate to where you want to put your project

	// A simple quickref for Eigen. Add anything that's missing.
	// Main author: Keir Mierle

	#include <Eigen/Dense>

	Matrix<double, 3, 3> A; // Fixed rows and cols. Same as Matrix3d.
	Matrix<double, 3, Dynamic> B; // Fixed rows, dynamic cols.
	Matrix<double, Dynamic, Dynamic> C; // Full dynamic. Same as MatrixXd.
	Matrix<double, 3, 3, RowMajor> E; // Row major; default is column-major.
	Matrix3f P, Q, R; // 3x3 float matrix.

	/**
	* Author: Asif Ahmed
	* Site: http://quickgrid.blogspot.com
	* Description: Inputting and Representing an Weighted Undirected graph
	* in adjacency list vector list pair using C++ STL.
	*/


	#include<bits/stdc++.h>
	using namespace std;

	#include <iostream>
	#include <fstream>
	#include <stdint.h>
	#include <vector>
	#include <algorithm>
	#include <string>
	#include <map>
	using namespace std;

	#pragma pack(push)

	import time

	class Bucket(object):
	def __init__(self, max_amount, refill_time, refill_amount):
	self.max_amount = max_amount
	self.refill_time = refill_time
	self.refill_amount = refill_amount
	self.reset()

	def _refill_count(self):

	#include <iostream>
	#include <vector>
	#include <assert.h>
	#include <cmath>
	#include <png++/png.hpp>

	using namespace std;

	typedef vector<double> Array;
	typedef vector<Array> Matrix;