-
Notifications
You must be signed in to change notification settings - Fork 15
What Next? January 2017
We began the meeting by welcoming new attendees and introducing ourselves before taking a moment to discuss potential changes to the club before we suggested new topics.
We discussed the struggle of working through difficult books while still remaining enticing to newcomers. The struggle with books such as Elements of Computing Systems was that attendance of the club dwindled over the months as missing a single chapter made it difficult to get back on-board (let alone someone wishing to join part way through). This wasn't the case for The New Turing Omnibus due to it having much more discrete chapters but some of us missed the opportunity to really delve into a specific topic.
To ensure we had a shared understanding of what people wanted out of the club, we discussed our motivations for attending at all:
- Working through practical exercises with others in an environment outside of their job
- The regular, scheduled nature of the club as a way of making time for areas of interest that might otherwise be neglected
- The opportunity to have conversations with like-minded people
- The chance to help others understand and teach about an area of expertise
- Get through book one might struggle with on their own
- Rediscover the joy at the heart of why we use computers in the first place
- The ability to explore the theoretical rather than practical
- A way of continuing education or making up for a lack of prior formal education in Computer Science
- The secret alter ego of the club as a bread appreciation society
One key idea that was raised was to try mixing the two paces of the club: have a longer book that we would work through together but also hold regular, "interstitial" meetings about other topics that would lend themselves better to newcomers.
With all of that in mind, several people then pitched their ideas for a new topic.
The following ideas were discussed in brief:
- 10 Print Chr (205.5+Rnd(1)); : Goto 10
- Cryptopals
- Types and Programming Languages
- Purely Functional Data Structures
- Think Complexity
- Seven Databases in Seven Weeks
- Seven Languages in Seven Weeks
- Professor Frisby's Mostly Adequate Guide to Functional Programming
- Making reliable distributed systems in the presence of software errors
- Elements of Programming
- Structure and Interpretation of Computer Programs
- Essentials of Programming Languages
- The Hut Six Story
- Let Over Lambda
- The Tangled Web
- Kattis
- 10 papers every programmer should read at least twice
- Proof systems (e.g. Isabelle and Coq)
We each then voted for topics we were interested in pursuing and the clear winner (with 10 votes) was Benjamin C. Pierce's "Types and Programming Languages" (aka TAPL).
As this is an academic textbook, we agreed that we would also take up the suggestion to hold regular meetings about topics outside the book to break up the pace. A suggestion for this was to pick the runner-up: one of the books from the "Seven $Things
in Seven Weeks" series.
With a larger book, we took the opportunity to plan several meetings ahead for the first time and decided on the following:
- First meeting about TAPL on Tuesday 7th February 2017
- Second meeting about TAPL on Tuesday 21st February 2017
- Third meeting about TAPL on Tuesday 7th March 2017
- First interstitial meeting about another topic on Tuesday 21st March 2017
We also proposed resurrecting a London Computation Pub on Tuesday 31st January 2017 to fill the gap before the first TAPL meeting.
We were conscious of the fact that, as a textbook, TAPL is much more expensive than other books we've tackled (at ~£50 from Amazon) so we decided to seek discounts and sponsorship to provide copies of the book for club members otherwise unable to acquire them.
Thank you to Leo and Geckoboard for hosting and to all those who contributed suggestions.
- Home
- Documentation
- Choosing a Topic
- Shows & Tells
- Miscellaneous
- Opt Art
- Reinforcement Learning: An Introduction
- 10 Technical Papers Every Programmer Should Read (At Least Twice)
- 7 More Languages in 7 Weeks
- Lua, Day 1: The Call to Adventure
- Lua, Day 2: Tables All the Way Down
- Lua, Day 3
- Factor, Day 1: Stack On, Stack Off
- Factor, Day 2: Painting the Fence
- Factor, Day 3: Balancing on a Boat
- Elm, Day 1: Handling the Basics
- Elm, Day 2: The Elm Architecture
- Elm, Day 3: The Elm Architecture
- Elixir, Day 1: Laying a Great Foundation
- Elixir, Day 2: Controlling Mutations
- Elixir, Day 3: Spawning and Respawning
- Julia, Day 1: Resistance Is Futile
- Julia, Day 2: Getting Assimilated
- Julia, Day 3: Become One With Julia
- Minikanren, Days 1-3
- Minikanren, Einstein's Puzzle
- Idris Days 1-2
- Types and Programming Languages
- Chapter 1: Introduction
- Chapter 2: Mathematical Preliminaries
- Chapter 3: Untyped Arithmetic Expressions
- Chapter 4: An ML Implementation of Arithmetic Expressions
- Chapter 5: The Untyped Lambda-Calculus
- Chapters 6 & 7: De Bruijn Indices and an ML Implementation of the Lambda-Calculus
- Chapter 8: Typed Arithmetic Expressions
- Chapter 9: The Simply-Typed Lambda Calculus
- Chapter 10: An ML Implementation of Simple Types
- Chapter 11: Simple Extensions
- Chapter 11 Redux: Simple Extensions
- Chapter 13: References
- Chapter 14: Exceptions
- Chapter 15: Subtyping – Part 1
- Chapter 15: Subtyping – Part 2
- Chapter 16: The Metatheory of Subtyping
- Chapter 16: Implementation
- Chapter 18: Case Study: Imperative Objects
- Chapter 19: Case Study: Featherweight Java
- The New Turing Omnibus
- Errata
- Chapter 11: Search Trees
- Chapter 8: Random Numbers
- Chapter 35: Sequential Sorting
- Chapter 58: Predicate Calculus
- Chapter 27: Perceptrons
- Chapter 9: Mathematical Research
- Chapter 16: Genetic Algorithms
- Chapter 37: Public Key Cryptography
- Chapter 6: Game Trees
- Chapter 5: Gödel's Theorem
- Chapter 34: Satisfiability (also featuring: Sentient)
- Chapter 44: Cellular Automata
- Chapter 47: Storing Images
- Chapter 12: Error-Correcting Codes
- Chapter 32: The Fast Fourier Transform
- Chapter 36: Neural Networks That Learn
- Chapter 41: NP-Completeness
- Chapter 55: Iteration and Recursion
- Chapter 19: Computer Vision
- Chapter 61: Searching Strings
- Chapter 66: Church's Thesis
- Chapter 52: Text Compression
- Chapter 22: Minimum spanning tree
- Chapter 64: Logic Programming
- Chapter 60: Computer Viruses
- Show & Tell
- Elements of Computing Systems
- Archived pages