|
|
|
Back to Index
|
A program is a set of instructions that tell the computer to do various things;
sometimes the instruction it has to perform depends on what happened when it performed a
previous instruction. This section gives an overview of the two main ways in which you
can give these instructions, or ``commands'' as they are usually called. One way uses an
interpreter, the other a compiler. As
human languages are too difficult for a computer to understand in an unambiguous way,
commands are usually written in one or other languages specially designed for the
purpose.
With an interpreter, the language comes as an environment, where you type in commands
at a prompt and the environment executes them for you. For more complicated programs, you
can type the commands into a file and get the interpreter to load the file and execute
the commands in it. If anything goes wrong, many interpreters will drop you into a
debugger to help you track down the problem.
The advantage of this is that you can see the results of your commands immediately,
and mistakes can be corrected readily. The biggest disadvantage comes when you want to
share your programs with someone. They must have the same interpreter, or you must have
some way of giving it to them, and they need to understand how to use it. Also users may
not appreciate being thrown into a debugger if they press the wrong key! From a
performance point of view, interpreters can use up a lot of memory, and generally do not
generate code as efficiently as compilers.
In my opinion, interpreted languages are the best way to start if you have not done
any programming before. This kind of environment is typically found with languages like
Lisp, Smalltalk, Perl and Basic. It could also be argued that the UNIX® shell (sh, csh) is itself an interpreter, and many people do in fact write
shell ``scripts'' to help with various ``housekeeping'' tasks on their machine. Indeed,
part of the original UNIX philosophy was to provide lots
of small utility programs that could be linked together in shell scripts to perform
useful tasks.
Here is a list of interpreters that are available as FreeBSD
packages, with a brief discussion of some of the more popular interpreted
languages.
To get one of these packages, all you need to do is to click on the hotlink for the
package, to download the package and then install the package by running:
# pkg_add package name
as root. Obviously, you will need to have a fully functional FreeBSD 2.1.0 or later
system for the package to work!
- BASIC
-
Short for Beginner's All-purpose Symbolic Instruction Code. Developed in the 1950s for
teaching University students to program and provided with every self-respecting personal
computer in the 1980s, BASIC has been the first
programming language for many programmers. It is also the foundation for Visual
Basic.
The Bywater Basic Interpreter and the Phil Cockroft's Basic Interpreter (formerly Rabbit Basic) are available
as FreeBSD packages.
- Lisp
-
A language that was developed in the late 1950s as an alternative to the
``number-crunching'' languages that were popular at the time. Instead of being based on
numbers, Lisp is based on lists; in fact the name is short for ``List Processing''. Very
popular in AI (Artificial Intelligence) circles.
Lisp is an extremely powerful and sophisticated language, but can be rather large and
unwieldy.
Various implementations of Lisp that can run on UNIX
systems are available as packages for FreeBSD. GNU
Common Lisp, CLISP by Bruno Haible and Michael Stoll, CMUCL which includes a highly-optimizing compiler too, or simpler Lisp
implementations, like SLisp which implements most of the Common Lisp constructs in a few
hundred lines of C code.
- Perl
-
Very popular with system administrators for writing scripts; also often used on World
Wide Web servers for writing CGI scripts.
Perl is available as a package for all FreeBSD releases, and is installed as /usr/bin/perl in the base system of 4.x releases.
- Scheme
-
A dialect of Lisp that is rather more compact and cleaner than Common Lisp. Popular in
Universities as it is simple enough to teach to undergraduates as a first language, while
it has a high enough level of abstraction to be used in research work.
FreeBSD has packages of the Elk
Scheme Interpreter, the MIT Scheme Interpreter and the SCM
Scheme Interpreter.
- Icon
-
Icon is a high-level language with extensive facilities for processing strings and
structures. A package is available for FreeBSD.
- Logo
-
Logo is a language that is easy to learn, and has been used as an introductory
programming language in various courses. It is an excellent tool to work with when
teaching programming in small ages, as it makes the creation of elaborate geometric
shapes an easy task even for very small children.
A package is available for FreeBSD of Brian Harvey's LOGO Interpreter.
- Python
-
Python is an Object-Oriented, interpreted language. Its advocates argue that it is one
of the best languages to start programming with, since it is relatively easy to start
with, but is not limited in comparison to other popular interpreted languages that are
used for the development of large, complex applications (Perl and Tcl are two other
languages that are popular for such tasks).
A package of the latest version of Python for FreeBSD is available here.
- Tcl and Tk
-
Tcl is an embeddable, interpreted language, that has become widely used and became
popular mostly because of its portability to many platforms. It can be used both for
quickly writing small, prototype applications, or (when combined with Tk, a GUI toolkit)
fully-fledged, featureful programs.
Various versions of Tcl are available as packages for FreeBSD. The latest version is,
as of this writing, Tcl version 8.3.
Compilers are rather different. First of all, you write your code in a file (or files)
using an editor. You then run the compiler and see if it accepts your program. If it did
not compile, grit your teeth and go back to the editor; if it did compile and gave you a
program, you can run it either at a shell command prompt or in a debugger to see if it
works properly.
Obviously, this is not quite as direct as using an interpreter. However it allows you
to do a lot of things which are very difficult or even impossible with an interpreter,
such as writing code which interacts closely with the operating system--or even writing
your own operating system! It is also useful if you need to write very efficient code, as
the compiler can take its time and optimize the code, which would not be acceptable in an
interpreter. Moreover, distributing a program written for a compiler is usually more
straightforward than one written for an interpreter--you can just give them a copy of the
executable, assuming they have the same operating system as you.
Compiled languages include Pascal, C and C++. C and C++ are rather unforgiving
languages, and best suited to more experienced programmers; Pascal, on the other hand,
was designed as an educational language, and is quite a good language to start with.
FreeBSD does not include Pascal support in the base system, but both GNU Pascal Compiler
(GPC) and the Free Pascal Compiler are available in the ports collection as lang/gpc and lang/fpc.
As the edit-compile-run-debug cycle is rather tedious when using separate programs,
many commercial compiler makers have produced Integrated Development Environments
(IDEs for short). FreeBSD does not include an IDE in
the base system, but devel/kdevelop is available in the ports tree and many use Emacs for this purpose. Using Emacs as
an IDE is discussed in Section 2.7.
|
|
|
|
© 2002-2004 Active-Venture.com
Website Hosting
Service
|
| |
|
Disclaimer: This
documentation is provided only for the benefits of our website hosting customers.
For authoritative source of the documentation, please refer to http://www.freebsd.org
|
|
|
