That's going to depend on a number of factors. I'm assuming here that you are using plain-vanilla R5RS Scheme with no libraries; if you can use the SRFI or SLIB forms, then a lot of this would be simplified, really.
Also, how much detail I need to go into will depend in what you already know of the language; from what you said, I'd have to start absolutely from scratch, which might not be appropriate.
Which interpreter or compiler are you using also can make a difference, especially as a total novice. I'll assume for now that you're using Dr Scheme (http://www.drscheme.org/) 3.01, and a lot of what I'll say below is specific to it, but if you aren't please let me know. If you are, you'll want to make sure that it's set to the right dialect; in the main menu, go to Language: Choose Language... and select 'Standard (R4RS)', hit 'Ok', then in the main editor hit the 'Run'.
OK, a few basics. Scheme is designed to be effectively compiled, but it is more often used through an interpreter, especially during development. Usually, the main interface is the Listener (and immediate interpreter prompt where you can enter smippets of Scheme code directly). In Dr Scheme, the main window is split into two sections, with (by default) the editor window at the top and the listener at the bottom. (This contrasts with most other Schemes, such as the MIT interpreter, which just give you the text-only listener; you need to invoke the editor for the listener, and it runs as a separate program. Some others work like the eLisp interpreter buffer, where you edit the code free-form, select the snippet to run, and then use a keystroke command to invoke the interpreter).
When you run code in the listener, it runs in a global environment known as the workspace; functions and variables created at the listener will last through the session, but get cleared when a new session is begun or the interpreter is closed. Using File: Log Definitions and Interactions, you can create a transcript of everything you are doing in the Listener for the rest of the current session. You can also save the current workspace definitions using File:Save Definitions as....
To create a separate program, you would enter the code into the edit window and save it as a normal source file. When you hit the 'Run' button, it creates flushes the existing session, creates a new session, and runs the code currently in the editor window.
If you haven't already, try typing in snippets of code like the ones below at the listener, to get a feel for the results:
(+ 2 2)
(define pi 3.14)
pi
(define (square x) (* x x))
(square 4)
(define (area-of-circle r) (* pi (square r)))
I've got to go right now, but I'll get back to you once you've replied on this; as I said, some idea of how much you know would help. If you haven't already looked at it, take a look at my tutorial, and maybe at some of the other oens linked to at Schemers.org (htp://www.schemers.org/).
For a taste of some more advanced Scheme: it is important the to remember is that in Lisp languages, most data structures are built out of the basic lists. For example, a binary tree
4
/ \
2 6
/ \ / \
1 3 5 7
might look like:
(4 (2 (1 3)) (6 (5 7)))
You can use lists to create most abstract data types, and the language even has built in support for certain ones (sets and associative lists in particular). However, you would not define a data structure type the way you might in C or Java (in basic Scheme at least; see SRFI 9 (http://srfi.schemers.org/srfi-9/srfi-9.html) for one library implementation of data structure types). Rather, you would define a series of functions that build the data structures from primitive lists, and populate, update, delete, etc. the data in them. This means that data manipulation has a somewhat higher overhead; however, it also gives a tremendous amount of flexibility in how you can manipulate data dynamically.