Archive for the 'Reading Groups' Category

Reading Groups Are Hard

January 8, 2009

In September we were all eager and hopeful little students. They stood up and told us how important we were to the department. They told us how much fun we would have, and how much they looked forward to our insightful contributions to human knowledge. They advised us, “Get Involved! Join the student society! Start reading groups with your new peers! Network!” 

Well, I listened. I started three reading groups, in fact. These groups are no longer active.

They fibbed. It was a happy and comforting piece of advice, meant to make us feel good about our new intellectual environment without any expectation that we would follow it. 

It’s hard to find a meeting time for a group that allows all the keen to participate. It’s hard to motivate people to keep up with readings without any external incentive. It’s hard to balance a regular hunk of reading with shifting priorities and irregular deadlines. It’s hard to stay one step ahead, choosing insightful readings when you know no more about a topic than anyone else.

Ignore Their banalities. There is little correlation between involvement in a graduate student society and success. Reading groups are hard and rare. Without a proper context and culture, energetic networking remains awkward even in an intellectual environment like ours. 

Paul Buchheit claims, “Limited Life Experiences + Overgeneralization = Advice.” The advice we were given follows a different and also common equation: “Idealized View of the World + Lack of Thought = Advice.”

In this case, the idealized view of grad school involves lots of stimulating conversation with a variety of brilliant intellects. The reality is that most of our time is spent on independent learning. This isn’t a value judgement—I’m personally happier than ever. I just want to point out the discrepancy.


October 21 Code Reading Meeting

October 22, 2008

We met in the DGP lounge (Projector that speaks DVI! Yes!) for an hour an went over the Django URL dispatch code. We talked about how Python is a good language for this group’s purposes.

We also debated the ideal format for a code reading group—we’ll get a good system worked out. The tradeoff is that it’s better for us all if we each go over some assigned code individually, but not everyone has the time to do it.

For next week (Tuesday, October 28, 5pm, BA 5181), we’re going to look at BitTorrent. We’ll collaboratively explore it at the meeting but those of us reading ahead should think about:

  • What optimizations could be put in for the one-server one-client case?

Before the meeting, everyone will send out their preferred tools, tricks and techniques for exploring an unfamiliar piece of Python code.

For my part, I like to browse around using a graphical debugger and an architecture diagram where possible but for now I’m stuck with TextMate and PDB.

October 9 Meeting of the Functional Programming Reading Group

October 9, 2008

We reviewed “Why Functional Programming Matters”, by John Hughes.

Along the way, we discussed some foundational FP concepts, such as currying, closures and functors.

Eventually, we’d like to move to a model where each meeting we cover a set of papers. Each of us reads a different one in depth and skims the others. At the meeting each of us will teach the deeply studied concepts to the others.

We agreed that we needed more foundational material before we begin to specialize. We also agreed that we’d like to move in a more theoretical direction for now—for example, we’ll look at some type theory, lambda calculus, and category theory.

I found an online book called “Type Theory and Functional Programming.” [PDF] We’ll read chapters 2 & 3 for the next meeting in two weeks: October 23.

Notes on “Why Functional Programming Matters”

October 8, 2008

Why Functional Programming Matters: John Hughes

Two functional language features, higher-order functions and lazy evaluation, allow for improved modularity in computer programs. For this reason, functional languages are important.

For example, reduce over lists and trees can be used to create other powerful functions such as sum, product and map. An abstraction for iterative improvement algorithms allows for simple square root calculations, derivatives and integrals. A combination of higher-order functions and lazy evaluation allows for a simple minimax implementation with alpha-beta pruning.

The first few examples given in this paper are drawn from the Structure and Interpretation of Computer Programs. This overlap makes me wonder: Perhaps functional languages are excellent for these specific tasks, or perhaps it is difficult to discover new generally useful functional abstractions.

October 3 Meeting of On Intelligence Reading Group

October 3, 2008

Everyone has now read the first part of “On Intelligence.” We’ll be reading the rest of the book by the next meeting in two weeks.

We discussed:

  • Searle & Turing vs. Functionalism
  • The true multitude of senses vs. the common five (sight hearing smell taste touch)
  • Artificial senses (e.g. the blind seeing through a tongue implant)
  • How artificial senses could be used for other inputs (e.g. You could feel the stock market or whether your servers are running)
  • How artificial senses combined with a working memory-prediction system could be used to extend our intelligence
  • How most current neural networks are uninteresting

September 25 Meeting of the Functional Programming Reading Group

September 26, 2008

We went over McCarthy’s Recursive Functions of Symbolic Expressions, discussed the paper and cleared up some confusion.

We’re going to try to meet at 5pm on Thursday October 9th, to allow for the people who have Algorithmic Software Verification at noon.

The paper to be discussed is “Why Functional Programming Matters,” by John Hughes. PDF Link.

Inaugural Meeting of the Code Reading Group

September 18, 2008

Sept 18 2008 10am, BA 5250. Four in attendance. I accept the blame for not sending a reminder and for people going to the wrong room.

We’ll meet again on Tuesday, September 30th at 5pm, and biweekly thereafter. Location to be announced as I’ll be trying to book a room with a projector.

Andrew will send out the URL of the “App Server”, which allows CS students access to Windows.

Some projects we’d like to look at:

  • GNU Coreutils (For Tuesday’s meeting!)
  • Google Chrome
  • jQuery (Note concerns that it may be too advanced for readers without a Javascript background)
  • A text editor, e.g. Nano
  • Django

We’re still looking for more suggestions and ideas.

Christian suggests we hold a “What does this Regex do?” puzzle biweekly and will choose the first one for our next meeting.

Inaugural meeting of Functional Programming reading group

September 17, 2008

Sept. 16 2008, Bahen 5250.

Six in attendance of nine on the list. Not a bad start.

Abe led a brief discussion of basics of FP for beginners, and suggests we check out Lambda the Ultimate.

We’ll meet again and BA 5250 on Thursday September 25th, 12pm-1pm. The paper to read is John McCarthy’s Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I.