introduction to development
The C language was developed in 1972 by Dennis Ritchie at Bell Telephone laboratories, primarily as a systems programming language. That is, a language to write operating systems with. Richie’s primary goals were to produce a minimalistic language that was easy to compile, allowed efficient access to memory, produced efficient code, and did not need extensive run-time support. Thus, for a high-level language, it was designed to be fairly low-level, while still encouraging platform-independent programming.
C ended up being so efficient and flexible that in 1973, Ritchie and Ken Thompson rewrote most of the UNIX operating system using C. Many previous operating systems had been written in assembly. Unlike assembly, which ties a program to a specific CPU, C’s excellent portability allowed UNIX to be recompiled on many different types of computers, speeding its adoption. C and Unix had their fortunes tied together, and C’s popularity was in part tied to the success of UNIX as an operating system.
In 1978, Brian Kernighan and Dennis Ritchie published a book called “The C Programming Language”. This book, which was commonly known as K&R (after the author’s last names), provided an informal specification for the language and became a de facto standard. When maximum portability was needed, programmers would stick to the recommendations in K&R, because most compilers at the time were implemented to K&R standards.
In 1983, the American National Standards Institute (ANSI) formed a committee to establish a formal standard for C. In 1989 (committees take forever to do anything), they finished, and released the C89 standard, more commonly known as ANSI C. In 1990 the International Organization for Standardization adopted ANSI C (with a few minor modifications). This version of C became known as C90. Compilers eventually became ANSI C/C90 compliant, and programs desiring maximum portability were coded to this standard.
In 1999, the ANSI committee released a new version of C called C99. It adopted many features which had already made their way into compilers as extensions, or had been implemented in C++.
C++
C++ (pronounced see plus plus) was developed by Bjarne Stroustrup at Bell Labs as an extension to C, starting in 1979. C++ adds many new features to the C language, and is perhaps best thought of as a superset of C, though this is not strictly true as C99 introduced a few features that do not exist in C++. C++’s claim to fame results primarily from the fact that it is an object-oriented language. As for what an object is and how it differs from traditional programming methodBefore we can write and execute our first program, we need to understand in more detail how C++ programs get developed. Here is a graphic outlining a simplistic approach:
Step 1:
Define the problem that you would like to solve.
This is
the “what” step, where you figure out what you are going to solve. Coming up
with the initial idea for what you would like to program can be the easiest
step, or the hardest. But conceptually, it is the simplest. All you need is an
idea that can be well defined, and you’re ready for the next step.
Here are
a few examples:
- “I
want to write a program that will allow me to enter numbers, then
calculates the average.”
- “I
want to write a program that generates a 2d maze and lets the user
navigate through it.”
- “I
want to write a program that reads in a file of stock prices and predicts
whether the stock will go up or down.”
Step 2:
Determine how you are going to solve the problem.
This is
the “how” step, where you determine how you are going to solve the problem you
came up with in step 1. It is also the step that is most neglected in software
development. The crux of the issue is that there are many ways to solve a
problem -- however, some of these solutions are good and some of them are bad.
Too often, a programmer will get an idea, sit down, and immediately start
coding a solution. This often generates a solution that falls into the bad
category.
Typically,
good solutions have the following characteristics:
- They
are straightforward.
- They
are well documented (especially any assumptions being made).
- They
are built modularly, so parts can be reused or changed later without
impacting other parts of the program.
- They
are robust, and can recover or give useful error messages when something
unexpected happens.
When you
sit down and start coding right away, you’re typically thinking “I want to do
_this_”, so you implement the solution that gets you there the fastest. This
can lead to programs that are fragile, hard to change or extend, or have lots
of bugs.
Studies
have shown that only 20% of a programmer’s time is actually spent writing the
initial program. The other 80% is spent debugging (fixing errors) or
maintaining (adding features to) a program. Consequently, it’s worth your time
to spend a little extra time up front before you start coding thinking about
the best way to tackle a problem, what assumptions you are making, and how you
might plan for the future, in order to save yourself a lot of time and trouble
down the road.
We’ll
talk more about how to effectively design solutions to problems in a future
lesson.
Step 3:
Write the program
In order
to the write the program, we need two things: First we need knowledge of a
programming language -- that’s what these tutorials are for! Second, we need an
editor. It’s possible to write a program using any editor you want, even
something as simple as Window’s notepad or Unix’s vi or pico. However, we
strongly urge you to use an editor that is designed for coding. Don’t worry if
you don’t have one yet. We’ll cover how to install one soon.
A typical
editor designed for coding has a few features that make programming much
easier, including:
1) Line
numbering. Line numbering is useful when the compiler gives us an error. A
typical compiler error will state “error, line 64”. Without an editor that
shows line numbers, finding line 64 can be a real hassle.
2) Syntax
highlighting and coloring. Syntax highlighting and coloring changes the color
of various parts of your program to make it easier to see the overall structure
of your program.
3) An
unambiguous font. Non-programming fonts often make it hard to distinguish
between the number 0 and the letter O, or between the number 1, the letter l
(lower case L), and the letter I (upper case i). A good programming font will
differentiate these symbols in order to ensure one isn’t accidentally used in
place of the other.
Your C++
programs should be called name.cpp, where name is
replaced with the name of your program. The .cpp extension tells the compiler
(and you) that this is a C++ source code file that contains C++ instructions.
Note that some people use the extension .cc instead of .cpp, but we recommend
you use .cpp.
Also note
that many complex C++ programs have multiple .cpp files. Although most of the
programs you will be creating initially will only have a single .cpp file, it
is possible to write single programs that have tens if not hundreds of
individual .cpp files.
Step 4:
Compiling
In order
to compile a program, we need a program called a compiler. The job
of the compiler is twofold:
1) To
check your program and make sure it follows the rules of the C++ language. If
it does not, the compiler will give you an error to help pinpoint what needs
fixing.
2) To
convert each file of source code into a machine language file called an object
file. Object files are typically named name.o or name.obj,
where name is the same name as the .cpp file it was produced
from. If your program had 5 .cpp files, the compiler would generate 5 object
files.
For
illustrative purposes only, most Linux and Mac OS X systems come with a C++
compiler called g++. To use g++ to compile a file from the command line, we
would do this:
g++ -c file1.cpp file2.cpp file3.cpp
This would
create file1.o, file2.o, and file3.o. The -c means “compile only”, which tells
g++ to just produce .o (object) files.
Other
compilers are available for Linux, Windows, and just about every other system.
We will discuss installing a compiler in the next section, so there is no need
to do so now.
For
complex projects, some development environments use a makefile,
which is a file that tells the compiler which files to compile. Makefiles are
an advanced topic, and entire books have been written about them. Fortunately,
you don’t need to worry about them, so we will not discuss them here.
Step 5:
Linking
Linking
is the process of taking all the object files generated by the compiler and
combining them into a single executable program that you can run. This is done
by a program called the linker.
In
addition to the object files for a program, the linker also includes files from
the runtime support library (or any other precompiled libraries you’re using,
such as graphics or sound libraries). The C++ language itself is fairly small
and simple. However, it comes with a large library of optional components that
may be utilized by your programs, and these components live in the runtime
support library. For example, if you wanted to output something to the screen, your
program would include a special command to tell the compiler that you wanted to
use the I/O (input/output) routines from the runtime support library.
Once the
linker is finished linking all the object files (assuming all goes well), you
will have an executable file.
Again,
for illustrative purposes, to link the .o files we created above on a Linux or
OS X machine, we can again use g++:
g++ -o prog file1.o file2.o file3.o
The -o
tells g++ that we want an executable file named “prog” that is built from file1.o,
file2.o, and file3.o
The
compile and link steps can be combined together if desired:
g++ -o prog file1.cpp file2.cpp file3.cpp
Which
will combine the compile and link steps together and directly produce an
executable file named “prog”.
Step 6:
Testing and Debugging
This is
the fun part (hopefully)! You are able to run your executable and see whether
it produces the output you were expecting. If not, then it’s time for some
debugging. We will discuss debugging in more detail soon.
Note that
steps 3, 4, 5, and 6 all involve software. While you can use separate programs
for each of these functions, a software package known as an integrated
development environment (IDE) bundles and integrates all of these
features together. With a typical IDE, you get a code editor that does line
numbering and syntax highlighting. You get a compiler and a linker. The IDE
will automatically generate the parameters necessary to compile and link your
program into an executable, even if it includes multiple files. And when you
need to debug your program, you can use the integrated debugger. Furthermore,
IDE’s typically bundle a number of other helpful editing features, such as
integrated help, name completion, hierarchy browsers, and sometimes a version
control system.
Introduction to Programming
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 acompiler. 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 (
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 from the FreeBSD Ports Collection, with a brief discussion of some of the more popular interpreted languages.
Instructions on how to get and install applications from the Ports Collection can be found in the Ports section of the handbook.
Instructions on how to get and install applications from the Ports Collection can be found in the Ports section of the handbook.
- 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 can be found in the Ports Collection as lang/bwbasic and the Phil Cockroft's Basic Interpreter (formerly Rabbit Basic) is available as lang/pbasic. - 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 in the Ports Collection for FreeBSD. GNU Common Lisp can be found as lang/gcl. CLISP by Bruno Haible and Michael Stoll is available as lang/clisp. For 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, lang/cmucl and lang/slisp are available respectively. - Perl
- Very popular with system administrators for writing scripts; also often used on World Wide Web servers for writing CGIscripts.
Perl is available in the Ports Collection as lang/perl5.16 for all FreeBSD 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.
Scheme is available from the Ports Collection as lang/elk for the Elk Scheme Interpreter. The MIT Scheme Interpreter can be found in lang/mit-scheme and the SCM Scheme Interpreter in lang/scm. - Icon
- Icon is a high-level language with extensive facilities for processing strings and structures. The version of Icon for FreeBSD can be found in the Ports Collection as lang/icon.
- 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 to smaller age groups, as it makes creation of elaborate geometric shapes an easy task.
The latest version of Logo for FreeBSD is available from the Ports Collection in lang/logo. - 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).
The latest version of Python is available from the Ports Collection in lang/python. - Ruby
- Ruby is an interpreter, pure object-oriented programming language. It has become widely popular because of its easy to understand syntax, flexibility when writing code, and the ability to easily develop and maintain large, complex programs.
Ruby is available from the Ports Collection as lang/ruby18. - 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 ports for FreeBSD. The latest version, Tcl 8.5, can be found in lang/tcl85.
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. [1]
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.
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 Collection and many use Emacs for this purpose.
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.
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 Collection and many use Emacs for this purpose.
Comments
Post a Comment