Kevin's Programming Page & Links

This is a Permi-Construction page.

Index

Index
Introduction
Programming Languages
- Assembly
- C/C++
- Java
- Scheme
Operating Systems, Hardware, and General info
Other Programming Pages
Revision History of this page

Introduction

I know the question that is probably on your mind. "Why in the world would someone put up a new page with programming information when there are so many out there?"

My simple answer to that question would be that I think there is some good information out there, but you have to wade through so much crap to get to it that it usually isn't worth the time. I hope to make this one of those pages that people would be looking for, and not the sewage that they have to wade through.

I know that it has been a long time since I have updated this page, and will probably be a very long time until I get it to somewhere near completed, but just stick around and little by little I will try to make this become one of those good resources.
Back to top

Programming Languages

The following sections will be about various programming languages, and will include some examples of how each of them look, and possibly a comparison of the different languages.

Scheme Programming

Scheme is a derivative of the LISP programming language. It is useful for processing data in lists. The standard programming style of this language is just ugly, and takes a while to be able to read.

Before reading through any of the examples below, there are some things that are important to know about scheme.

It is an interpreted language.
All statements are surrounded by parentheses.
It is a dynamically typed language. This means that the types of any given variable are not known until runtime (this includes anything passed to a function).
It is a strongly typed language. There is no means of deciding at some point that an object should be changed into a different type with the same data (ie. casting in C/C++ will allow you to change anything into anything else).
Identifier names may contain characters that other languages don't allow. As an example, 'some-helper', and 'ident?' are valid identifier names.
Functions may be created dynamically using 'lambda' statements (An example will appear below).

Note that I am not doing much programming in scheme anymore, so this section may not be changing very much.

Here is a simple example of some scheme. The '(void)' statement here makes this function return no value.

;start of scheme example 1
(define (loopy val max)
  (display val)             ;display the number
  (newline)                 ;set cursor to new line
  (if (>= val max)          ;check to see if val > max
    (void)                  ;if so, return nothing
    (loopy (+ val 1) max))) ;if not, call loopy with val+1
  
(loopy 0 10)  ;display all the numbers from 0 to (and including) 10
;end of scheme example 1

This is the way that iteration is accomplished in scheme. The interpreter determines when the return value from the function is a call to the same function and removes the recursive call, replacing it with a 'loop' (a process known as 'Tail Recursion Elimination').

That example was really simple, so here is a little more complex one.

;start of scheme example 2
;
;Note here that the following two statements are equivalent.  They both return
;whatever they were passed.
;
;(define function (lambda (x) x))
;
;(define (function x) x)

;A recursive factorial. This will not be able to do tail recursion
;elimination, as the value of num must be saved to do the multiply in the last
;line.
(define fact1
  (lambda (num)
    (if (= num 0)
      1
      (* num (fact1 (- num 1))))))

;A helper function for an iterative factorial.  This will be able to do tail
;recursion elimination, as nothing in the function needs to be saved for when
;the 'recursive' call returns.
(define (fact2_helper product num)
  (if (= num 0)
    product
    (fact2_helper (* product num) (- num 1))))

;call the helper function, with the initial product of 1, and the number
;given.
(define (fact2 num)
  (fact2_helper 1 num))


;A third factorial where the helper function is defined internally.
(define (fact3 num)
  (letrec ((fact3_helper       ;define a local variable, who's name can be used
			       ;to call it recursively.
	   (lambda (product num)
	     (if (= num 0)
	       product
	       (fact3_helper (* product num) (- num 1))))))
    (fact3_helper 1 num)))

;example uses.
(display (fact1 10))    ;display 3628800
(newline)

(display (fact2 10))    ;display 3628800
(newline)

(display (fact3 10))    ;display 3628800
(newline)
;end of scheme example 2

Operating Systems, Hardware, and General info

The following sections will discuss programming in different operating systems, for various pieces of hardware, and possibly include some hints for general programming.