-
Notifications
You must be signed in to change notification settings - Fork 15
The New Turing Omnibus Show & Tell
We began the meeting with an especially large glut of snacks with a vaguely festive theme (though Tom was disappointed not to find accidentally vegan mince pies in Tesco) and decided to work chronologically through our meetings since our last retrospective, showing off any software we'd built along the way.
We started with Search Trees but unfortunately Jamie's visual implementation is no longer available and Paul struggled to remember his implementation in Ruby and his associated misadventures with persistent data structures.
We then moved onto Random Numbers and enjoyed rediscovering a visualisation of the logistic function that a few members of the club had built together to explore its chaotic behaviour. We put Geckoboard's AirPlay to the test by sharing Kevin's amazing visualisation of pseudo-randomness.
We skimmed through Predicate Calculus as there was no software produced and moved onto Perceptrons and the first of Chris' many canvas-based adventures.
Mathematical Research came next and had some of the most memorable implementations as it featured the Mandelbrot set:
- Tom's visualisation of the orbits of numbers in the algorithm
- Tom's visualisation of the Mandelbrot set
- Tom's visualisation of Julia sets
- Chris' visualisation of the Mandelbrot set with variable number of iterations
We then moved onto Genetic Algorithms and Tom's interactive plot of one featuring everyone's favourite button label: "Breed, Mutate, Cull?"
We rewatched a poor bipedal creature being pelted by boxes and Tom mentioned a recent video of Hayao Miyazaki being shown similar simulations and having a rather... strong reaction.
We marvelled at yet more canvas wizardry from Chris with his visualisation of genetic algorithms solving the Travelling Salesperson problem.
We moved onto Public Key Cryptography and got our first taste of Chris' programming language Sentient in his Subset Sum solver.
We played a thrilling game of noughts and crosses against an intelligence of our own devising both in Ruby and in the browser thanks to the Game Trees meeting.
Next was Gödel's Theorem and Chris' Gödel number encoder/decoder.
Having seen Sentient develop over the course of the year, it was time to revisit a meeting (and one of our most popular at that) all about it: Satisfiability. We marvelled at Chris' visualisation of Sentient's execution model and only mildly teased him about implementing so much layout logic in canvas, "if only the browser had some way to draw boxes with text in".
We skimmed past the code written by various pairs during our Cellular Automata meeting and rediscovered a highlight of the year: Chris' Quad Trees/Mandelbrot/Minimax mashup game.
With little time left, Leo demonstrated his noisy command-line utility written for Error Correcting Codes and moved onto any software written outside the meetings but inspired by the club.
Paul demonstrated and explained a pagination technique he'd developed with the help of the club for use at his day job to optimise for users accessing pages at the beginning and end of very large ranges, e.g. to over 1 million pages.
Inspired in no small part by the amount of Silicon Valley he was watching at the time, this "middle-out" pagination works by flipping the order, limit and offset of database queries around a central pivot in a range of rows. This is based on the assumption that the first page of a result set ordered in one direction (e.g. by score and primary key ascending) is the same as the last page ordered in the opposite direction (e.g. by score and primary key descending). The club was instrumental in helping calculate the right limit and offset: specifically translating a page number which will always be incrementing into a limit and offset that might be coming from either end of the result set.
Chris then demonstrated a parser he'd written to work with a text-based file format using the Parslet gem.
Finally, Tom demonstrated the latest version of his Lambda Calculus workshop which is now a React, browser-based application rather than being a command line tool as it was when he ran the meeting for the club.
We decided to take a break over the Christmas holidays and return in the new year to start a new topic as voting for The New Turing Omnibus seemed to reveal that we were done with the book.
Thanks to Leo and Geckoboard for hosting, to Tom for driving and his photographs, Chris for demoing his parser, everyone who built things over the past year and to all those who contributed to the festive cornucopia of snacks we enjoyed.
- 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