Advice for students

Via Planet Ubuntu i read Aaron Toponces Good Advice For Computer Science Students. Read his article! For reference here is the short version of the list:

  1. Practice the fundamentals (For example solve exercises in The Art of Programming)
  2. Seek challenges (Write 100,000 lines of code)
  3. Practice, practice, practice
  4. Don’t forget about mathematics
  5. Develop a team spirit and to learn how to work well with others
  6. Encourage innovation, and don’t necessarily stick to the authors code in the books
  7. Work strategically (Part time jobs, pick good bosses/environments)

Originally this list seems to come from a Dr. Kai-fu Lee from Google China.

Published in: on May 26, 2007 at 9:55 am  Leave a Comment  

Your turn

I’ll be away for some days, so the only chance something is happening here is you.

What’s your opinion on “the most important problems in computer science?

Or do you have a suggestion, whom i should mail?

Published in: on May 17, 2007 at 7:07 am  Leave a Comment  

No idea, but it’s interesting

Turns out i’m not the only one on this quest. Simon Peyton-Jones wrote back:

I wish I knew what the most important problems are. Then I could work on them.

What I do know is that functional programming is full of interesting problems. I hope they will turn out to be important too, but you only know for sure in retrospect.

Peyton-Jones is the principal designer of GHC and works at Microsoft Research. I recently read one of his papers on Software Transactional Memory and i think he does good work.

Published in: on May 16, 2007 at 6:17 pm  Leave a Comment  

May it be correct and efficient

I got a response from another professor of mine. I enjoyed Peter Sanders “Informatik 3” course, which was about machine models and SAT for large parts. Here comes an answer from the rather theoretical algorithm camp of computer scientists.

Generally speaking, CS is concerned with building software and hardware that is

  • correct
  • efficient

Since I am working on algorithmics, the foundations of the latter area, let me make that more concrete there. You want to design, analyze and implement efficient algorithms for the problems that are most important / frequently used. Hence, you can look at building blocks that are used in many applications or more specific problems that show up in particularly important applications. Here is a sample of important building blocks that I happen to have worked on (but I do not claim here that my contributions are important):

  • sorting
  • dictionaries
  • shortest path search
  • full text search
  • collective communication in networks
  • load balancing

That feels a little “back to the roots”, but it shows that we still need to think about the basics. An example i can think of is a cuckoo hashing from 2001.

Published in: on May 16, 2007 at 12:16 pm  Leave a Comment  

Programming for everybody

Walter F. Tichy is the first one in this roundup i’ve seen in person. He was my professor in the Softwaretechnik course (“software engineering”) and i’m currently in a workshop about Transactional Memory at his IPD. He wrote rcs, one of the first version control systems.

Das wichtigste Problem der Informatik ist die Programmierbarkeit.

Rechner sollten von jedermann programmierbar sein, ohne langwierige technische Ausbildung. Heute ist für die meisten Menschen das Programmieren viel zu kompliziert, wodurch Software zu einer Engpasstechnnik geworden ist. Erst wenn jedermann Rechner routinemäßig programmieren kann, vielleicht in dem er Rechnern mündliche Anweisungen gibt so wie er es heute mit anderen Menschen tut, ist das Problem der Programmierbarkeit gelöst. Wenn jedermann nicht nur Rechner benutzt, sondern sie auch anweist, wird das zu einer Explosion an neuen Fähigkeiten führen, die Rechner und rechnergesteuerte (vernetzte) Geräte übernehmen können. Erst dann erfüllt die Informatik ihr Potenzial, nämlich die Menschen von ermüdender, langweiliger, fehleranfälliger oder gefährlicher Arbeit zu befreien.

N.B.: Mit Programmieren meine ich das Erstellen von Handlungsanweisungen, nicht nur das bloße Einstellen
von Parametern wie z.B. auf einem Videorecorder oder einem Mobiltelephon, was ja auch manchmal als “Programmieren” bezeichnet wird.

My translation:

The most important problem in computer science is programmability.

Computer should be programmable by everyone without tedious, technical education. Today programming is much too complicated for most people, so software has become scarce (Engpasstechnik?). When everybody can routinely program a computer, maybe by giving verbal commands, like you do with humans, then the problem of programmability is solved. When everybody doesn’t just use a PC, but commands it, then this will lead to an explosion of new things, which computers and controlled machines can do. Only then computer science has fullfilled its potential, which is to free humanity from tiresome, boring, error-prone and dangerous work.

Btw with “programming” i mean the construction of commands, not only adjusting parameters like for example with a video recorder or a mobile phone. Sometimes that is called “programming”, too.

Note to self: Only ask in english from now on!

There is a common theme here. It started with Kernighan (programming is still too difficult) and continued with Felleisen who works on making programming better. Tichy uses an entirely different way, though. Felleisen works on programming language level and Tichy rather on the tool level.

Published in: on May 15, 2007 at 3:53 pm  Leave a Comment  

Matthias Felleisen replies

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.

For some more information, see my web page especially the Papers and Research page.

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.

Published in: on May 15, 2007 at 2:38 pm  Leave a Comment  

Software should be as good as a TV

The answers are rolling in and i’ll work through them one by one.

Our next answer comes from Andrew S. Tanenbaum, known from public fights with Linus Torvalds about Microkernels. He wrote several very good books about operating systems. Tanenbaum has a very direct and visionary answer.

The most important problem is making software secure and reliable. Software should be as good as a TV set: the average user will not have ANY failures of any kind in a 10-year ownership period.

I’m not so sure about the TV sets, but unfailing software is a good goal. He adds a link to his project, which i will happily forward to you.

I am working on that. See

If you didn’t know. Minix3 isn’t just the learning exercise Minix was. Minix3 is intended to become a real world operating system.

Published in: on May 14, 2007 at 9:32 pm  Leave a Comment  

Computers are still too hard

I’ve got the first reply to the first batch of emails i sent out. I’m honored to show you the answer of Brian Kernighan. He’s most famous for the The C Programming Language (sometimes referred to as “K&R”), but did some work on other languages and algorithms, too.

When I first began using computers over forty years ago, it seemed that programming was too difficult and machines were harder to use than they should be. Much has changed since then, but in spite of great advances, programming is still too difficult and machines are still too hard to use. Those are the important problems.

That is a very general answer and i hope i’ll get some more specific ones. Nevertheless i feel … excited … vivified after this first reply. Thank you very much Mr Kernighan!

Published in: on May 14, 2007 at 1:59 pm  Comments (2)  

Hello world!

I’m starting this blog to document my journey into the vast fields of computer science. My current idea is to send a nice email to some people i don’t know and ask them about computer science. The email will look like this:

Richard Hamming in his talk “You and your research” asked three good questions: What are the most important problems in your field? What are you working on? Why aren’t they the same? In this spirit i’d like to hear your opinion:

What are the most important problems in computer science?

Let’s see what the reactions are.

Published in: on May 13, 2007 at 3:06 pm  Comments (9)