Here is a brief explanation of how files and buffers work, to make more sense of Scheme's open, close, read and write functions. Most devices, including terminal output and network connections, but especially hard disk storage, fundamentally accept information in fixed size chunks (lines of text, packets of data, blocks on disk). In particular, a hard disk is optimized so that it can get large amounts of data quickly back and forth between storage and main memory. Think of how itunes has to work. That means that communication between the disk and memory is not very fine grained. You don't ask the disk for one byte. You might as well ask for thousands. The same goes for sending information to the disk. Programs, however, often compute with small amounts of data at a time. You may want to read or write just one byte. The way I/O operations work is designed to allow the programs to work the way they have to work and to allow the disk to work the way it has to work. The basic idea is that files are associated with a buffer, which is memory storage that duplicates content that has been read from a file and hasn't been consumed by the program yet, or content that has been created by the program but hasn't been written to the file yet. In other words, when you read data in a program, the operating system first looks at the buffer for the file, and gives you copied data if it's available. If there's no data in the buffer, then you need to go to disk again. So the operating system reads in a large chunk of data to fill its buffer. Then it returns the next unit of data out of that buffer that the program has asked for. Because buffers can be large and the operating system has fixed resources, there are only a certain number of buffers available for each running program, so it's important to close files for reading when you're done with them to make the buffer space available to read other files. Conversely for writing, when you do a write call, the operating system just adds the new information to the buffer for the open file. When the buffer fills up, and you have enough data that's worth writing to the disk, the operating system physically writes all the data in the buffer to the disk and empties the local buffer. This means that the information that you write doesn't immediately show up on the disk. The only way to know for sure that file writing is completed is to close the file, which writes the buffer and discards it, or to flush the buffer, which causes an immediate write of all the available data (which can be pretty wasteful in terms of the time it takes to access the disk and the inefficient use of the resources of the disk in manipulating very small amounts of data). If you want to store information in a file in Scheme code and then use it later, that means you want to have code something like this. ; writes '(0 1 2) to the file "blah.scm" ; overwriting the existing contents, if any ; then reads the contents of "blah.scm" in ; final thing returned is the read value ; opens the file and will 'replace what's there (let ((p (open-output-file "blah.scm" 'replace))) ; instruction to write the data - stores it in a buffer (write '(0 1 2) p) ; finish with the file - synchronizes buffer and disk (close-output-port p)) ; open the file for reading (let ((q (open-input-file "blah.scm"))) ; store the first scheme construct temporarily as a (let ((a (read q))) ; done with the file - close the port (close-input-port q) ; return what we read in a))