Computer Science for Self-Taught Programmers

When people talk about Big O notation do you go cross eyed? Do you not get the point of learning about implementing linked lists or depth first search? Join me as I introduce the CS fundamentals that helped me ace my Google interview, even though I didn't get a formal CS education.

Talk given at PyCon 2014 in Montreal

Transcript

1. Justin Abrahms Computer Science for the self taught programmer http://bit.ly/1gfszix
2. Who am I? • Justin Abrahms • Director of Product Engineering at Quick Left • Author of Imhotep • @justinabrahms or github://justinabrahms
3. Overview • How I learn about Big O? • What is Big O? • How is Big O done? • Resources and learned wisdom
5. A sane data model
6. Our data model
7. Our ACTUAL data model
8. What does N+1 Selects look like? entries = get_post_ids() final_list = [] for entry_id in entries: entry = get_entry(entry_id) final_list.append(entry)
9. Questions • How did I miss this? • How did this guy know about it and I didn’t? • How can I make sure this never happens again.
10. –Wikipedia (aka Inducer of Impostor Syndrome) In mathematics, big O notation describes the limiting behavior of a function when the argument tends towards a particular value or infinity, usually in terms of simpler functions.
11. –Me Big O is how programmers talk about the relation of how much stuff is being done when comparing two pieces of code.
12. Google Study List Studied: • Data Structures • Algorithms • System Design • Java Internals • Concurrency Issues
13. Google Study List Studied: • Data Structures! • Algorithms! • System Design • Java Internals • Concurrency Issues These are Big O things
14. –Wikipedia A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.
15. –Wikipedia An algorithm is a step-by-step procedure for calculations
16. O(n)
17. What sorts of Big O are there? • O(1) — Constant Time • O(log n) — Logarithmic Time • O(n) — Linear Time • O(n²) — Quadratic Time • O(n!) — Factorial Time
18. Intentionally left blank for people in the back
19. def get_from_list(idx, lst): return lst[idx] O(1)
20. def item_in_list(item, lst): for entry in lst: if entry == item: return True return False O(n)
21. Wait a second…
22. def item_in_list(item, lst): for entry in lst: if entry == item: return True return False O(n) — Broken Down
23. def item_in_list(item, lst): for entry in lst: O(n) if entry == item: return True return False O(n) — Broken Down
24. def item_in_list(item, lst): for entry in lst: O(n) if entry == item: O(1) return True return False O(n) — Broken Down
25. def item_in_list(item, lst): for entry in lst: O(n) if entry == item: O(1) return True O(1) return False O(1) O(n) — Broken Down
26. def item_in_list(item, lst): for entry in lst: O(n) if entry == item: O(1) return True O(1) return False O(1) O(n) — Broken Down =O(n) * O(1) + O(1)
27. Why don’t we say Big O of O(n) * O(1) + O(1)?
28. In non-“math-y” terms • If we plot our function, we can also plot M * the big O and end up with a line that our function never crosses (for certain values of X)
29. Example O(n) * O(1) + O(1) Big O: To Plot: ?
30. Example O(n) * O(1) + O(1) Big O: To Plot: x * ? O(n) always means x
31. Example O(n) * O(1) + O(1) Big O: To Plot: x * 5 + 9 O(1) means pick any constant number
32. Example To Plot: x * 5 + 9
33. Example To Plot: x * 5 + 9
34. Example To Plot: x * 5 + 9
35. Is it O(1)? To Plot: x * 5 + 9
36. Is it O(n²)? To Plot: x * 5 + 9
37. Big O is an approximation of algorithmic complexity
38. def item_in_list(item, lst): for entry in lst: if entry == item: return True return False O(n)
39. What if the list is empty?
40. def item_in_list(item, lst): for entry in lst: if entry == item: return True return False O(n)
41. O(log n) The best example of O(log n) is binary search.
42. O(log n) 1 2 3 4 5 6 7 8 9 10
43. O(log n) 1 2 3 4 5 6 7 8 9 10 4
44. O(log n) 1 2 3 4 5 6 7 8 9 10 4
45. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 6?
46. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 6? Nope.
47. O(log n) 1 2 3 4 5 6 7 8 9 10 4
48. O(log n) 1 2 3 4 5 6 7 8 9 10 4
49. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 3?
50. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 3? Nope.
51. O(log n) 1 2 3 4 5 6 7 8 9 10 4
52. O(log n) 1 2 3 4 5 6 7 8 9 10 4
53. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 4?
54. O(log n) 1 2 3 4 5 6 7 8 9 10 4 == 4? Yes!
55. def get_pairs(lst): pair_list = [] for i1 in lst: for i2 in lst: pair_list.append([i1, i2]) return pair_list ! O(n²)
56. def get_pairs(lst): pair_list = [] O(1) for i1 in lst: O(N) for i2 in lst: O(N) pair_list.append([i1, i2]) O(1) return pair_list O(1) ! O(n²)
57. def get_pairs(lst): pair_list = [] O(1) for i1 in lst: O(N) for i2 in lst: O(N) pair_list.append([i1, i2]) O(1) return pair_list O(1) ! O(n²) = O(1) + O(n) * O(n) * O(1) + O(1)
58. O(n²) = O(1) + O(n) * O(n) * O(1) + O(1)
59. O(n²) = O(1) + O(n) * O(n) * O(1) + O(1)
60. O(n²) = O(1) + O(n) * O(n) * O(1) + O(1) = O(n) * O(n) * O(1) + O(1) + O(1)
61. O(n²) = O(1) + O(n) * O(n) * O(1) + O(1) = O(n) * O(n) * O(1) + O(1) + O(1) = x * x + 7 + 9 + 13
62. O(n²) = O(1) + O(n) * O(n) * O(1) + O(1) = O(n) * O(n) * O(1) + O(1) + O(1) = x * x + 7 + 9 + 13 = x² + 29
63. O(n²) = x² + 29
64. O(n²) = x² + 29
65. O(n²) = x² + 29
66. O(n²) = x² + 29
67. Gotchas
68. The Big O of a function might not matter
69. Theoretical speed is different than practical speed.
70. This is probably not going to make your app faster.
71. Resources
72. Resources http://algorist.com/
73. Resources https://www.coursera.org/course/algo
74. Resources https://leanpub.com/computer-science-for-self-taught-programmers/
75. How do I write my code differently now?
76. Knowing Big-O doesn’t make you write your code differently.
77. Big O is… • useful in communicating about complexity of code • basic arithmetic and algebra • used in talking about algorithms and data structures • not as hard as it originally sounds
78. Thanks • justin@abrah.ms • @justinabrahms • github.com/justinabrahms Credits: ! NYC slide photo via flickr://Andos_pics