Nicky Case Talk Summary

This is my notes from a talk that I attended by https://ncase.me/. in March. I took notes on the lecture, as well as some prompted questions I got during her talk.

  • Why do we lose that sense of learning as an adult? It would be great if everyone was learning new things, but at one point did we settle for cheap thrills. The best things to do is to go for activities that have dual purpose, or kill two birds with one stone.
  • For novice learners, passive is better than active. Advanced learners - > active is better than passive. Expertise reversal. This makes sense, but I don’t know if the boundary between expert learner and passive learner is clear. For example, let’s say that you’re a programmer. But if you programmed before and you want to pick up a functional programming language, should you just hack away, or get your fundamentals down? I think you should do both at the same time and reinforce as you go.
  • Working memory is the bottleneck. 4+-1 chunks. Make sense. Similar to CPU/computer caching. Why do we have this 4+-1 chunks? What is the explanation for this number?
  • Memory is determined by patterns and summarizing.
  • Advanced learner already has the nets and the foundations to create new learning. This is true.
  • Weak learners working memory becomes overwhelmed.
  • Look into cognitive load theory
  • How can we apply all this theory to programming/coding? You don’t really read a lot of code on a daily basis.
  • Pair the right content load with the right brain. This also depends on the resting status of your brain.
  • I liked building a ship inside a bottle picture. There’s definitely something deep about this, which I may explore a bit later.
  • You should build one neural connection at a time strategy. The ideal gap for a learner is one connection away.
  • All learning must require connection to things already known. Do not build from scratch.
  • Effective learning requires a reasonable difficulty level set. You can’t just throw the learner into the far deep end out of nowhere.

I’m very interested in the learning process in general. One of the biggest things that we should work on is allowing students to make tons of mistakes, as many of them as possible without fear. I think we learn from making mistakes. For me, I remember the times I’ve screwed up more than my major successes. It’s NOT because I always screw up.

Other books to look into:

Why students like school? Daniel Willingham

Marvin Minsky Society of Minds

Flights are Insane

I made a trip to South Korea last August, and I was on a plane for 14 hours.

It is insane if you think about it. Everything. How large the plane is. The fact that you can travel half way across the world in 14 hours. How you fly through so high that you can only see clouds. How the wings on the airplane just flap back and forth to control the air zipping. How the airplane cuts through the sky. Thirty-thousand feet in the air at speeds no human can dare to ever achieve. Sometimes I think it’s bullshit. How many of the humans in existence ever got to be that high up in the air? How many would kill for the experience?

I’m still in awe of the technology. How there probably so many damn pieces that must all fit together for this airplane to function without error. Every single part and component. Every fundamental discovery on how the electron operates, and how current travels from point A to point B comes to use. Thousands and thousands of capacitors, resistors, and transistors placed by hundreds of engineers. Late hours into the night where the frontiers buckled down and explored uncharted intellectual territories. Countless hours soldering into the night and probably some zaps as well.

When I’m on thee airplane, I thought about how many people that have rode on an airplane before me, and how many will use this technology after me. How much impact technology will have on people’s lives. It will allow, for people like me, to see loved ones that are separated by thousands of miles apart.

I also get scared every time on airplanes. I know that probability wise, it’s highly unlikely I’ll get killed on a plane. The probability is crazy low. But don’t you think that everyone that got killed on a plane thought that way? Or everyone who ever died in a major accident?

“Ah it’s nothing. I’ll be fine. The chances of me dying on an airplane is super-low. Not gonna happen.”

Then bam. Dead.

<To-be-continued, because I don’t have energy =(.>

Economics, delays - probability of a delay? How no one can actually do anything if flights get delayed. Time taken to go somewhere. Energy comparison and consumption on all modes of transportation as a visual, and how much every we’d need for warm holes on plot.

The cheapness of flights. What are the margins per flight ride. How the airline company balance sheets look like.

Why People Don't Ask Questions

I read this great post from Jon Gjengset(https://thesquareplanet.com/blog/why-dont-people-ask-questions/) on the topic of asking questions. It made me reflect a bit on questions and why I didn’t ask more questions during my time in school. The reasons were many, but I was usually the type to go up to the Professor after class because I was afraid I’d waste everyone else’s time. For certain topics I was interested in, go to office hours instead. But yes, I wasn’t an active participant in the class many of the time.

There are couple of reasons why people don’t want to ask questions:

  1. People don’t want to look dumb. If you’re asking a question, you’re revealing to the entire group of people that you didn’t understand X. Sometimes, this could be good, sometimes this can be bad. There’s a certain sense of humility involved in asking questions, and not giving a crap about what other people think about you. People judge about what kind of questions you ask - “Ah how can this person not know this?” To blatantly ask questions without a filter, you need a huge amount of self-confidence and to some degree honesty. My take on this is that - you should just ask. People don’t even remember what they had for breakfast. They won’t remember your stupid questions. And sometimes even dumbest questions are often insightful.
  2. **** You’re afraid that you tuned out for a couple of minutes, and the lecturer already discussed what you are going to ask.**** I had this happen a lot of the times. For whatever reason, my mind likes to wonder. But maybe.. it’s just not me. Doesn’t everyone’s mind do this? Our brains are huge filters, and parallel processors. I find it hard to believe that our brains can remain concentrated on one thing for the entirety of 45 minutes of the class.
  3. People don’t care about the material. They want to pass the class and get out. This is sad, but on the other hand, I can relate. There were a couple of classes in my life where I tuned out because I just didn’t have interest. This tended to happen a lot with politics and history classes because it was a regurgitation of facts and the reasoning for why the facts came to be were not thoroughly explained nor engaging. No matter how much I tried, I just didn’t have the natural curiosity to be actively engaged.
  4. They don’t want to slow down the Prof. This is a legitimate reason. Doesn’t this underline the flaws of our education system? Why do we have to watch a lecture and participate passively for an hour? Ideally, the class should be flipped so that we don’t learn the material during lecture, but discuss the underlying assumptions and topics that we want clarified. This is also known as a flipped classroom. I had a class like this, where we would watch the Professor’s lectures during our own time, come to class one day work on an assessment, and on the following class form groups and discuss our questions with the Professor and TAs going around answering questions. At the end of the class, we would submit it to the Professor for grading and feedback. I didn’t find this particularly effective, mainly because of the free-loader problem and the tradeoff you make with this approach is that the Professor has to repeat information to multiple groups, and the interaction with the Professor is minimal.

    Hmm.. maybe one way is to have the students learn the things on their own, have them take a daily quiz to check their understanding, and have a re-take at the end of the class to correct their mistakes. Whatever it is, we need more feedback - that’s the main concept that corrects mistakes and steers learners towards the correct path.

I think asking questions is a fundamental skill that we should foster in our society. Only by asking questions, can we find new doors, prune out and deeply understand the assumptions that go in building systems, and find gaps in our understanding.

Anyhow, maybe we should do something to incentive students to ask questions and participate. Maybe extra credit for good questions. Or use technology during the lecture, so that students can anonymously ask questions in real-time! Perhaps the way we teach is all wrong - possibly the reason why we don’t have active participation in our classes is due to resource constraints. Or even psychological safety. Maybe, maybe if we have extremely groups of 4 - 5 balanced students teaching each other, won’t that improve our ability to ask questions and have very meaningful discussions? How can we design education systems so that the incentives all align so that we can maximize learning and growth?

Assumptions in Code

A friend asked me this programming multiple choice question that’s been driving me nuts. Not because it was a particularly hard question, but it was just full of holes.

Given this code, what is the run-time complexity:

sum = 0
for(i = 0; i < n^2; i++)
	for(j=0; j < n; j++)
    	for(k=0; k <j; k++)
        	sum++;

It didn’t take me long to figure out that the “correct” answer is that this code has the time complexity of O(n^4). Simple cs 101.

Reasoning:

The first loop takes n^2 time. Check.

The second and third loop run like this:

when j = 0, k =0, but k < j doesn’t hold. 0 runs.

when j = 1, k = 0, -> 1 run.

when j = 2, k = 0, 1, –> 2 runs.

when j = 3, k = 0, 1, 2…. -> 3 runs.

This turns out to be a summation formula: sum(1 + 2+ 3+ 4+ 5+ … n-1), which is (n-1)*(n-1+1)/2.

Combining this with the first loop, the run time is O(n^2 * (n-1)*n/2).

All in all, the time complexity is O(n^4).

But this could be wrong based under certain assumptions.

Breaking Assumption 1: Suppose that this is the second time running this code. Or the third time. If the computer running this program caches the result(s) in the computer cache, then it’s a O(c) operation. Constant time lookup. Woohoo! Done.

Breaking Assumption 2: I heard a story that clang or other compilers are super-smart. They don’t run this code, they figure out that the above code can be converted into summation formulas. So the answer is always going n^3(n+1)/2. The computer doesn’t need to run any loops! Which is probably ~a couple of load(1?) operation from the computer, and maybe 4 multiplication operations, 1 addition, and 1 division. Probably less than 20 operations total. Which is still constant amount of cpu instructions regardless of n. So it’s still constant time operations independent of the size of n.

So yes, it’s O(n^4) under certain conditions. Ugh. But considering that Big O notation is taking the asymptotic bound for the worst case situation, I guess this is the safe, right answer. But under certain conditions, there is no way the asymptotic behavior would ever be O(n^4). It really depends on your environment and other extra details.

I was super curious of what optimizations the compiler makes, and coded this up on my computer in C and generated some assembly afterwards.

 #include <stdio.h>
 #include <stdlib.h>
 int main(int argc,char* argv[]) 
 { 
  
    int n = atoi(argv[1]);

    int i, j, k = 0;
    int sum = 0;
    for (i = 0; i < n*n; i++){
        for (j = 0; j < n; j++){
            for (k = 0; k < j; k++){
              sum++;
            }
        }
    }
    printf("%d", sum);
    return 0;
   

 } 

Then I converted this to assembly with clang and gcc, and started digging around:

gcc, no optimizations:

	.file	"dumbq.c"
	.section	.rodata
.LC0:
	.string	"%d"
	.text
	.globl	main
	.type	main, @function
main:
.LFB2:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$48, %rsp
	movl	%edi, -36(%rbp)
	movq	%rsi, -48(%rbp)
	movq	-48(%rbp), %rax
	addq	$8, %rax
	movq	(%rax), %rax
	movq	%rax, %rdi
	call	atoi
	movl	%eax, -4(%rbp)
	movl	$0, -12(%rbp)
	movl	$0, -8(%rbp)
	movl	$0, -20(%rbp)
	jmp	.L2
.L7:
	movl	$0, -16(%rbp)
	jmp	.L3
.L6:
	movl	$0, -12(%rbp)
	jmp	.L4
.L5:
	addl	$1, -8(%rbp)
	addl	$1, -12(%rbp)
.L4:
	movl	-12(%rbp), %eax
	cmpl	-16(%rbp), %eax
	jl	.L5
	addl	$1, -16(%rbp)
.L3:
	movl	-16(%rbp), %eax
	cmpl	-4(%rbp), %eax
	jl	.L6
	addl	$1, -20(%rbp)
.L2:
	movl	-4(%rbp), %eax
	imull	-4(%rbp), %eax
	cmpl	-20(%rbp), %eax
	jg	.L7
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE2:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609"
	.section	.note.GNU-stack,"",@progbits

clang, no optimizations:

	.text
	.intel_syntax noprefix
	.file	"dumbq.c"
	.globl	main
	.align	16, 0x90
	.type	main,@function
main:                                   # @main
	.cfi_startproc
# BB#0:
	push	rbp
.Ltmp0:
	.cfi_def_cfa_offset 16
.Ltmp1:
	.cfi_offset rbp, -16
	mov	rbp, rsp
.Ltmp2:
	.cfi_def_cfa_register rbp
	sub	rsp, 48
	mov	dword ptr [rbp - 4], 0
	mov	dword ptr [rbp - 8], edi
	mov	qword ptr [rbp - 16], rsi
	mov	rsi, qword ptr [rbp - 16]
	mov	rdi, qword ptr [rsi + 8]
	call	atoi
	mov	dword ptr [rbp - 20], eax
	mov	dword ptr [rbp - 32], 0
	mov	dword ptr [rbp - 36], 0
	mov	dword ptr [rbp - 24], 0
.LBB0_1:                                # =>This Loop Header: Depth=1
                                        #     Child Loop BB0_3 Depth 2
                                        #       Child Loop BB0_5 Depth 3
	mov	eax, dword ptr [rbp - 24]
	mov	ecx, dword ptr [rbp - 20]
	imul	ecx, dword ptr [rbp - 20]
	cmp	eax, ecx
	jge	.LBB0_12
# BB#2:                                 #   in Loop: Header=BB0_1 Depth=1
	mov	dword ptr [rbp - 28], 0
.LBB0_3:                                #   Parent Loop BB0_1 Depth=1
                                        # =>  This Loop Header: Depth=2
                                        #       Child Loop BB0_5 Depth 3
	mov	eax, dword ptr [rbp - 28]
	cmp	eax, dword ptr [rbp - 20]
	jge	.LBB0_10
# BB#4:                                 #   in Loop: Header=BB0_3 Depth=2
	mov	dword ptr [rbp - 32], 0
.LBB0_5:                                #   Parent Loop BB0_1 Depth=1
                                        #     Parent Loop BB0_3 Depth=2
                                        # =>    This Inner Loop Header: Depth=3
	mov	eax, dword ptr [rbp - 32]
	cmp	eax, dword ptr [rbp - 28]
	jge	.LBB0_8
# BB#6:                                 #   in Loop: Header=BB0_5 Depth=3
	mov	eax, dword ptr [rbp - 36]
	add	eax, 1
	mov	dword ptr [rbp - 36], eax
# BB#7:                                 #   in Loop: Header=BB0_5 Depth=3
	mov	eax, dword ptr [rbp - 32]
	add	eax, 1
	mov	dword ptr [rbp - 32], eax
	jmp	.LBB0_5
.LBB0_8:                                #   in Loop: Header=BB0_3 Depth=2
	jmp	.LBB0_9
.LBB0_9:                                #   in Loop: Header=BB0_3 Depth=2
	mov	eax, dword ptr [rbp - 28]
	add	eax, 1
	mov	dword ptr [rbp - 28], eax
	jmp	.LBB0_3
.LBB0_10:                               #   in Loop: Header=BB0_1 Depth=1
	jmp	.LBB0_11
.LBB0_11:                               #   in Loop: Header=BB0_1 Depth=1
	mov	eax, dword ptr [rbp - 24]
	add	eax, 1
	mov	dword ptr [rbp - 24], eax
	jmp	.LBB0_1
.LBB0_12:
	movabs	rdi, .L.str
	mov	esi, dword ptr [rbp - 36]
	mov	al, 0
	call	printf
	xor	esi, esi
	mov	dword ptr [rbp - 40], eax # 4-byte Spill
	mov	eax, esi
	add	rsp, 48
	pop	rbp
	ret
.Lfunc_end0:
	.size	main, .Lfunc_end0-main
	.cfi_endproc

	.type	.L.str,@object          # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"%d"
	.size	.L.str, 3


	.ident	"clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)"
	.section	".note.GNU-stack","",@progbits

gcc O3 optimization:

	.file	"dumbq.c"
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC0:
	.string	"%d"
	.section	.text.unlikely,"ax",@progbits
.LCOLDB1:
	.section	.text.startup,"ax",@progbits
.LHOTB1:
	.p2align 4,,15
	.globl	main
	.type	main, @function
main:
.LFB38:
	.cfi_startproc
	subq	$8, %rsp
	.cfi_def_cfa_offset 16
	movq	8(%rsi), %rdi
	movl	$10, %edx
	xorl	%esi, %esi
	call	strtol
	movl	%eax, %edi
	xorl	%edx, %edx
	xorl	%r8d, %r8d
	imull	%eax, %eax
	testl	%eax, %eax
	je	.L3
	.p2align 4,,10
	.p2align 3
.L10:
	xorl	%esi, %esi
	testl	%edi, %edi
	jle	.L4
	leal	1(%rsi), %ecx
	cmpl	%edi, %ecx
	je	.L4
	.p2align 4,,10
	.p2align 3
.L16:
	testl	%ecx, %ecx
	jle	.L6
	leal	1(%rdx,%rsi), %edx
.L6:
	movl	%ecx, %esi
	leal	1(%rsi), %ecx
	cmpl	%edi, %ecx
	jne	.L16
.L4:
	addl	$1, %r8d
	cmpl	%r8d, %eax
	jne	.L10
.L3:
	movl	$.LC0, %esi
	movl	$1, %edi
	xorl	%eax, %eax
	call	__printf_chk
	xorl	%eax, %eax
	addq	$8, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE38:
	.size	main, .-main
	.section	.text.unlikely
.LCOLDE1:
	.section	.text.startup
.LHOTE1:
	.ident	"GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.11) 5.4.0 20160609"
	.section	.note.GNU-stack,"",@progbits

clang O3 optimization:

	.text
	.intel_syntax noprefix
	.file	"dumbq.c"
	.globl	main
	.align	16, 0x90
	.type	main,@function
main:                                   # @main
	.cfi_startproc
# BB#0:
	push	rbx
.Ltmp0:
	.cfi_def_cfa_offset 16
.Ltmp1:
	.cfi_offset rbx, -16
	mov	rdi, qword ptr [rsi + 8]
	xor	ebx, ebx
	xor	esi, esi
	mov	edx, 10
	call	strtol
	mov	ecx, eax
	imul	ecx, ecx
	test	ecx, ecx
	je	.LBB0_3
# BB#1:
	test	eax, eax
	jle	.LBB0_3
# BB#2:                                 # %.preheader.lr.ph.us.preheader
	lea	edx, [rax - 1]
	lea	esi, [rax - 2]
	imul	rsi, rdx
	shr	rsi
	lea	edx, [rax + rsi - 1]
	test	ecx, ecx
	mov	edi, 1
	cmovg	edi, ecx
	dec	edi
	imul	edi, edx
	add	edi, eax
	lea	ebx, [rsi + rdi - 1]
.LBB0_3:                                # %._crit_edge10
	mov	edi, .L.str
	xor	eax, eax
	mov	esi, ebx
	call	printf
	xor	eax, eax
	pop	rbx
	ret
.Lfunc_end0:
	.size	main, .Lfunc_end0-main
	.cfi_endproc

	.type	.L.str,@object          # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"%d"
	.size	.L.str, 3


	.ident	"clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)"
	.section	".note.GNU-stack","",@progbits

Results:

Without optimizations, the assembly code follows the logic and loops. With optimizations, it’s skipping all this with xor computations, and reduces the number of instructions. But it still doesn’t seem to use the obvious summation formulas(not quite sure…)… =(. OK - It’s not a couple of cpu operations. Unfortunately, I’m super rusty in my assembly, so I’ll have to explore this a a bit more another time. But I can almost swear that this code can be written in assembly in a couple of instructions and should not be dependent on n…

Honest Review of the Recurse Center

My Recurse Center batch(Winter 2 2019 is the best!) officially ended Friday. It’s one of the best experiences I had in my life. I will surely miss it.

I’m going back to my hometown in the suburbs of D.C., take some time to read and relax, and hopefully travel for a bit after while I’m planning my next steps. The most likely outcome is to come back to New York to work.

Reasons to Come to the Recurse Center:

  • You will learn things you didn’t know you didn’t know.
  • There’s a diverse range of programmers with different skillsets. It strikes a nice balance, because you get an opportunity to help and share your knowledge. At the same time, there are always people to learn programming from. Because everyone has different backgrounds, you get to pick up on other interesting things.
  • People at Recurse are super nice and friendly. Recurse has an interview process where they optimize for picking people based on their passion and whether they’re someone Recursers would get along with(That’s my theory anyway). I didn’t interact with everyone in my batch, maybe because we never got a chance to talk or wasn’t on the same wavelength. But I found no one that was outright rude or mean. Yet.
  • You get access to a community of 1500 people on Recurse Center’s private messaging board. That’s one more community you can ask programming questions or other life questions.
  • Collaboration. You do get a chance to collaborate on projects together and pair up, if you choose to do so.
  • Sometimes, while you’re working on your projects alone, it can get lonely, or possibly stuck. What I found inspirational was that there was always someone passionately hacking away and learning when I felt drained, and that I could talk to others to take a quick break.
  • Recurse is free.

Reasons Against:

  • Money doesn’t grow on trees. Let’s say that you need 7k to fund yourself for Recurse. It’s not only 7k, but you also have to factor in the opportunity cost of what you could have been doing when you’re not at Recurse. Which is a lot of monies.
  • You want to focus only on working on your project at maximal velocity. Then it may be better to stay home. There will be distractions(some good, like getting to know some really cool things you didn’t know, but others not as good). James, an alumni, said this: If your sole reason is to come to Recurse to work on your project flying solo, Recurse may not be the best option for you. I mean, you can work on your passion project by yourself right? So expect your original goals to shift.
  • You are an early stage programmer and want to get a job through Recurse’s partner companies. Many of their partner companies mostly want senior software engineers.
  • Sometimes, you feel that you’re not good enough because other people are doing amazing things and you’re either not making a lot of progress, or learning something that doesn’t have tangible results. But the other side of the coin is that the work of others rekindles your fire to learn.
  • New York is hectic and noisy. Well that’s not a Recurse thing, but I couldn’t think of any other con ¯\(ツ__/¯

Recommended Optimal Recurse Strategy:

Get a job that you really love, and take a sabbatical. One of the Recurse facilitators mentioned this before I started my batch. People have a hard time juggling between planning their next steps, and enjoying the Recurse experience. I would have loved my batch much more if I took a sabbatical, didn’t have to worry about interview prep, and went ham!

Some Recursers got their companies to fund their learning experience. This is sick. If you love your job, but want a break, you should definitely ask! You’re going to end up becoming a better programmer, so the company should invest in your 3 month ordeal!

Also, it’s better if you’re not strapped for cash. It’s stressful to worry about money when you don’t have any. It’s good to save up some money so you can go out often and explore New York!

Advice to Future Recursers:

  1. Introduce yourself to other Recursers as soon as possible. The sooner you do this, the less awkward the two of you will be. Sometimes, you never really introduce yourself to each other, so naturally you tend to avoid talking to each other because it’s gotten awkward. It’s a crappy feedback loop, so don’t do it.
  2. Organize study groups and find people to learn together. I recommend this because it’s a lot more fun this way, and you get to clarify missing pieces in whatever you are studying. Or go in-depth through another side discussion.
  3. Don’t be afraid to ask to join in on the conversation. But don’t be afraid to bounce as well.
  4. Ask away. Personally I don’t think there is a dumb question. I saw this blog post recently which is relevant(https://thesquareplanet.com/blog/why-dont-people-ask-questions/). It’s pretty safe here.
  5. Give presentations. You get a chance to do 5 minute presentations every week. In retrospect, this is what I should have done more(I gave 2 during my stay). If you’re bad at public speaking, this is an excellent, low-risk way to improve.
  6. Pair program often. There are some interesting tools and ideas that I’ve picked up during the few sessions I’ve had with others.

Overall, I highly recommend attending the Recurse Center for anyone interested.

*Nothing is permanent in life, so this blog post is subject to revision =D.

My Recurse Center batch(Winter 2 2019 is the best!) officially ended Friday. It’s one of the best experiences I had in my life. I will surely miss it.

I’m going back to my hometown in the suburbs of D.C., take some time to read and relax, and hopefully travel for after while I’m planning my next steps.

Reasons to Come to the Recurse Center:

  • You will learn things you didn’t know you didn’t know.
  • There’s a diverse range of programmers with different skillsets. It strikes a nice balance, because you get an opportunity to help and share your knowledge. At the same time, there are always people to learn programming from. Because everyone has different backgrounds, you get to pick up on other interesting things.
  • People at Recurse are super nice and friendly. Recurse has an interview process where they optimize for picking people based on their passion and whether they’re someone Recursers would get along with(That’s my theory anyway). F I didn’t interact with everyone in my batch, maybe because we never got a chance to talk or wasn’t on the same wavelength. But I found no one that was outright rude or mean. Yet.
  • You get access to a community of 1500 people on Recurse Center’s private messaging board. That’s one more community you can ask programming questions or other life questions.
  • Collaboration. You do get a chance to collaborate on projects together and pair up, if you choose to do so.
  • Sometimes, while you’re working on your projects alone, it can get lonely, or possibly stuck. What I found inspirational was that there was always someone passionately hacking away and learning when I felt drained, and that I could talk to others to take a quick break.
  • Recurse is free.

Reasons Against:

  • Money doesn’t grow on trees. Let’s say that you need 7k to fund yourself for Recurse. It’s not only 7k, but you also have to factor in the opportunity cost of what you could have been doing when you’re not at Recurse. Which is a lot of monies.
  • You want to focus only on working on your project at maximal velocity. Then it may be better to stay home. There will be distractions(some good, like getting to know some really cool things you didn’t know, but others not as good). James, an alumni, said this: If your sole reason is to come to Recurse to work on your project flying solo, Recurse may not be the best option for you. I mean, you can work on your passion project by yourself right? So expect your original goals to shift.
  • Your an early stage programmer and want to get a job through Recurse’s partner companies. Many of their partner companies mostly want senior software engineers.
  • Sometimes, you feel that you’re not good enough because other people are doing amazing things and you’re either not making a lot of progress, or learning something that doesn’t have tangible results. But the other side of the coin is that the work of others rekindles your fire to learn.
  • New York is hectic and noisy. Well that’s not a Recurse thing, but I couldn’t think of any other con ¯\(ツ__/¯

Recommended Optimal Recurse Strategy:

Get a job that you really love, and take a sabbatical. One of the Recurse facilitators mentioned this before I started my batch. People have a hard time juggling between planning their next steps, and enjoying the Recurse experience. I would have loved my batch much more if I took a sabbatical, didn’t have to worry about interview prep, and went ham!

Some Recursers got their companies to fund their learning experience. This is sick. If you love your job, but want a break, you should definitely ask! You’re going to end up becoming a better programmer, so the company should invest in your 3 month ordeal!

Also, it’s better if you’re not strapped for cash. It’s stressful to worry about money when you don’t have any. It’s good to save up some money so you can go out often and explore New York!

Overall, I highly recommend attending the Recurse Center for anyone interested. It’s changed my perspective on life, and reinvigorated me to continue learning just for the sake of it.

*Nothing is permanent in life, so this blog post is subject to revision =D.

Site built with http://lanyon.getpoole.com/ template. Thanks to @mdo for the original template!