I encountered Matthias Felleisen on the PLT scheme mailinglist. If you try PLT (with assistance of the HtdP book), you will encounter some of his ideas and some Scheme experience doesn’t hurt anybody.
His answer is the most extensive so far.
I am working on three problems that for me are the most fun and the most important:
The migration of scripts to well-founded programs
Programming languages – my speciality – has experienced a renaissance over the past 10, 15 years. In addition to new reasonable mainstream languages, a large crop of scripting languages has emerged as the tool of choice to produce useful software.
People are beginning to realize, however, that scripts are difficult to maintain. A lot of design information is hidden, so that new people have a hard time understanding how they work.
We are working on a framework, methods, and tools for overcoming this problem.
Creating “macros” that really work
Lisp introduced macros as mechanisms for abbreviating patterns that functions couldn’t abbreviate. Scheme advanced this idea, introducing the idea that macros could be syntactic abstractions (hygiene, referential transparency, phase distinctions, pattern-based analysis and creation, etc). Unfortunately, we’re still not able to use macros as easily and as seamlessly as other forms of abstractions, especially functions. My goal is to change that.
Bringing theorem proving to the masses
My work is always associated with teaching. For the past year or so, I have been thinking on how to get theorem proving into the freshman year (first year of college).
My group and I are building software based on top of ACL2 and DrScheme, and we are developing a curriculum. Last semester we have test-run the curriculum with select freshmen. The test showed that it is feasible and that it has tremendous advantages over traditional approaches to integrating logic into CS. Still, we have a long way to go and it will take significant research to get there.
Furthermore he had some criticism to the question itself.
In my mind, such a question doesn’t denote. Computer Science is -at least to some extent- an engineering discipline, meaning people create/design new artifacts rather than just solve existing problems. The middle ground is to work on new artifacts and to keep the world-at-large in mind so that others can apply your new
creations and ideas to their problems.
For mathematicians or natural scientists, it makes sense to ponder Hamming’s question. Even an outsider can understand and agree that “what holds the world together” is an important problem in physics.
So if you wish, you can approach mathematical computer scientists and ask them what they consider the most important problems. But then you do so, keep in mind that they are closer to mathematics than to computer science. Put differently, you must make up a mind whether you want to ask
- “mathematicians” in our field (people who prove theorems about things computational)
- “software engineers” (people who build large systems that compute and communicate)
- “computer scientists” (people who produce application-quality software and constructs models of important aspects of their work and debug models via theorems)
These are distinct groups and kinds of people. I belong to the last.
I agree to some extend. The question is better to answer in the theoretical camp. For the engineers it translates to the question of motivation. “Why?” A question everybody can (or should) answer. Andrew Tanenbaum rather fits into the “software engineer” drawer and his answer was rather general, but interesting and valid enough to be mentioned. On the other hand i’m still waiting for the “P=NP?” answer.
The question needs some refinement after the first round. That’s for sure.