Tyler Neely spacejam

The Big Blob of Compute Hypothesis

Dario Amodei

1. Introduction

I've considered several times writing up my overall perspective on AGI safety. The main reason I haven't done so so far is that my view of the problem is pretty high-level -- it's from a different genre than the kind of "framework-y" agendas that Paul and Eliezer have written, and in fact a big part of it is arguing that such frameworks operate on the wrong level of abstraction (although that said, Paul's framework is broadly compatible with things that I think, whereas Eliezer's framework is broadly incompatible). However, then I realized that the core belief behind my safety perspective is also central to my perspective on AGI timelines, so it seemed particularly important to write it up. Some caveats: this is not a precise hypothesis or one I'm super confident in, and I have additional, more specific, reasons for holding both my views on AGI timelines and my views on AGI safety. It's more like a distillation of my high-level intuitions

using rust with rr

rr is a great debugging tool. it records a trace of a program's execution, as well as the results of any syscalls it executes, so that you can "rewind" while you debug, and get deterministic forward and reverse instrumented playback. it works with rust, but by default if you try it out, it could be pretty ugly when you inspect variables. if this bothers you, configure gdb to use a rust pretty-printer

rr is probably in your system's package manager.

	// states:
	// A can transition to B.
	// B can transition to either A or End.
	// End terminates.

	#[derive(Debug)]
	struct A;

	#[derive(Debug)]
	struct B;

	struct MutableIter<'a, A> {
	// reference to underlying buffer
	inner: &'a mut [A],
	// state to keep track of how far along we are
	index: usize,
	}

	impl<'a, A> Iterator for MutableIter<'a, A> {
	// associated types
	type Item = &'a mut A;

	pub struct Fib16 {
	seed: u16,
	lfsr: u16,
	bit: u16,
	}

	impl Default for Fib16 {
	fn default() -> Fib16 {
	Fib16 {
	seed: 0xACE1u16,

	use std::io::{Result, Read, Write};
	use std::net::{TcpListener, TcpStream};

	fn handle_client(
	mut stream: TcpStream,
	state: &mut Vec<String>,
	) -> Result<()> {
	Ok(())
	}

	#[macro_use]
	extern crate quickcheck;
	extern crate rand;
	extern crate btree;

	use self::quickcheck::{Arbitrary, Gen};

	// The maximum key size. keeping it relatively
	// small increases the chance of multiple
	// operations being executed against the same

	struct Node<K, V>
	where
	K: Ord
	{
	key: K,
	value: V,
	left: Option<Box<Node<K, V>>>,
	right: Option<Box<Node<K, V>>>,
	}

	struct Node<K, V>
	where
	K: Ord + Sized,
	V: Sized,
	{
	key: K,
	value: V,
	left: Option<Box<Node<K, V>>>,
	right: Option<Box<Node<K, V>>>,
	}

	#![feature(asm)]
	#![feature(i128_type)]

	fn cas128(val: &mut u128, old: u128, new: u128) -> Result<u128, u128> {
	// old
	let rdx: u64 = (old >> 64) as u64;

Tyler Neely spacejam

The Big Blob of Compute Hypothesis

1. Introduction

using rust with rr

usage