I'm noticing a lack of course II types (or any non course 6/18 types, actually) in the descriptions, and I'd like to rectify that. I was thinking of talking about something thermo-related, since that stuff is fascinating but not necessarily something that all majors get exposed to.
Before I left MIT, I co-founded a consulting company which then became my full-time job until I returned to MIT. During the past few years, we had dozens of clients and actually paid everyone a good salary! These talks will be a series focusing on different aspects of what I learned from running a consulting company.
Talk 1: It's like 40 first dates...
Introduction to Vestal (my
company), what we did and how we did it. We'll also be talking about what is
consulting, how to consult and how to get clients.
Anyone can benefit from this talk.
I'm giving a slugtalk on the financial crisis! How it started, overview of mortgage market, what the major threats are now.
First, I'll be introducing Quizlet.com, a web app I've been working on since 2005. Its focus is helping students learn vocabulary; I've just created a vocabulary set on MIT's course numbers if you want a little preview.
When thinking about optimizing a website's speed, most people focus on tuning the back-end. While that's important, I'll be focusing on dramatic gains that can be made by reducing page weight and making browsers render objects as soon as they receive them. Topics will likely include: minifying all page objects, using CSS sprites, making sure as many objects as possible are non-blocking, cached, and downloaded in parallel, reducing HTTP requests and DNS lookups, and a few other tricks. I will also touch on localizing javascript files and pre-processing both CSS and javascript.
There's no math or theory here, so it should be very accessible.
I'm going to give a Slugtalk on how I survived my first semester at MIT. Some of you heard the punchline for the lecture, but please don't spoil it for others.
What this talk will be about:
What this talk will not be about:
The talk should be accessible to anybody as there is no technical subject material. Freshmen, in particular, probably have the most to gain from this talk.
I'll be talking about what I worked on at my internship this past summer (or at least, some of what I worked on — NDAs are annoying like that). I'll start by defining and explaining the execution dag model of parallel programs, and then talking about how to look at the entire execution dag of a parallel program and draw conclusions about the performance of said program on various numbers of processors. Then, I'll explain in detail a clever way to do the same analysis online (that is, while the program is running, before the whole dag has even been determined) by instrumenting the binary of a program written in Cilk++, without adding to the time or space complexity of the running program.
This talk should be pretty accessible, although the second half may be harder to follow for non-programmers. For a primer on the talk, you can read this e-book published by Cilk.
Spoken term detection is the task of searching spoken documents for particular words or phrases. In this talk I will be discussing methods for spoken term detection and how it becomes more difficult as new words enter into a language. I will also talk about ways in which it can be improved: pronunciations for new or unknown words can be extracted from the web, and the use of 'fuzzy matching' methods can aid in the retrieval by considering more alternatives for pronununciations of words.
I talked a bit about how you can index and search through graphs comprised of many alternate possibilities rather than just the 1-best transcription — if you'd like to read more about how that is done, take a look at the paper General Indexation of Weighted Automata — Application to Spoken Utterance Retrieval by Cyril Allauzen, Mehryar Mohri, and Murat Saraclar.
Martí adds: There is an easier-to-read (larger font, single column) paper on the same subject by the same authors, Weighted Finite-State Transducers in Speech Recognition, in case you're old and crusty and your eyes don't work so good no more.
I'll be talking about what I've been working on for the past 6 months. Basically it's about how to make cell phones, internet tablets, and PDAs know their current location in the world and what's near them/around them. The buzz term for this sort of thing is making devices "context aware."
All of the material should be very approachable, as most of it is laying out the problems with the ways things are currently done, and describing at a high level how our approach will (hopefully) solve all of those problems.
I spent a good part of my summer working with antimagic edge labelings (bijective assignments of {1, 2, ..., |E(G)|} to E(G) such that all vertex sums are distinct...better definition to come at the talk), an exciting and new (younger than me) branch of graph theory. Relatively little is known about antimagic labelings, although there is a strong conjecture that appears to be consistent based on all current results. I'll present two theorems I found/proved during the summer (currently the only known results on trees) after providing a comprehensive introduction to the subject. The talk should be accessible to anyone who can wipe their own ass, including incoming frosh.
These labelings also fall under the category of recreational mathematics, so non-18ers should find something of interest if not application.
The relevant paper is Antimagic Labelings and the Antimagic Strength of Graphs by Wes Brown. There are also slides from the presentation.
I spent my summer working on solvers for POMDPs (Partially Observable Markov Decision Processes), a class of problem which models an agent acting in an environment about which it has uncertain information, in which it attempts to maximize a reward. The POMDP is able to capture an extremely wide variety of decision problems, and as such, it would be nice to have a software framework for solving them efficiently.
Unfortunately, solving the most general class of POMDP is PSPACE-complete (i.e., an efficient solver would imply a major result in complexity theory).
However, there is hope that a large and useful class of POMDPs can be solved efficiently by a general solver. I spent my summer exploring this class; I'll be talking about the possible POMDP instances which are efficiently solvable by computer.
I'm going to aim my talk at a high-level description of the problems, rather than an in-depth analysis of algorithms. As such, the talk should be generally accessible.
Erica will be talking about awesome things. The particular awesome things she will be talking about are continuations and concurrency.
References from the talk: process continuations and composable continuations.
This talk won't be "high brow" but will cover stuff that you definitely need to know to be an educated course 6-er. I plan to talk about what exactly is meant by pointers, references, and values. From there I'll discuss how different languages use them and how that affects what the language is and is not capable of doing (at least C++, Java, and Python). I promise I will point out some flaws of these languages as well as some neat things.
I'll be giving a talk on the Cilk programming language, which is a parallel language based on C that was developed at CSAIL. I'll be explaining the basic ideas behind the language, and the some of the algorithmic theory on which it is based. Knowledge of C won't be necessary.
If you want to read up on Cilk, take a look at the Cilk website. In particular, these slides contain basically everything I said and more.
What that hell is CPS? What the hell is a continuation? I'll be talking (sort of) about that. At the end I'll talk about this neat optimization you can perform on CPS programs that eliminates the stack/procedure call overhead for certain kinds of non-tail recursive calls.
The relevant paper is Recycling Continuations by Jonathan Sobel and Daniel P. Friedman.
I'm talking about dependent types. It'll (conveniently) build on Matt's type theory basics.
The paper I'm referencing is: Why Dependent Types Matter by Thorsten Altenkirch, Conor McBride, and James McKinna.
Another one that I've read that is tangentially related (talks about the idea of structural recursion) is Total Functional Programming by D. A. Turner (ignore the obvious programming error on the first page).
What if your type-checker could prove that your program terminates? While, then either your type-checker or your language would be Turing incomplete, but there's some pretty cool research there nonetheless. Find out MOAR at my talk.
I'll be saying stuff about polymorphic typechecking. It will build on the type theory stuff I talked about a couple weeks ago, but it should still be totally understandable even if you weren't there last time.
I'll be speaking tonight about type theory. My hope is to give a basic introduction, and lead up to what I call the source/sink problem: what it is, where it rears its ugly head (e.g. in Java arrays), and how to deal with it.
Most of this comes from the book Types and Programming Languages by Benjamin Pierce, an excellent textbook on type theory.
Martí's going to be saying things about things relating to Erlang, and it's going to be awesome.
The very first Slugtalk!
I'll be talking about Packrat Parsing, a parsing algorithm that guarantees linear runtime on the input size while allowing for infinite lookahead (unlike the LALR parsers generated by yacc and similar tools, which allow only limited lookahead in order to get linear runtime). I'll include a brief overview of parsing and of other parsing techniques, so there shouldn't be any significant prereqs for this talk.
The paper that most of this talk is coming from is Packrat Parsing: Simple, Powerful, Lazy, Linear Time by Bryan Ford.