TOOLS

• Languages, compilers and assemblers

  Most every programmer needs the tools listed in this section since you need them to translate your thoughts into a running program. A language is a set of statements designed to present your thoughts to the machine. Most languages today at least share almost the same set of control statements and also offer some way to use program flow mechanisms. The most important distinction between languages today is between OO(oriented) and procedural languages. The compiler and assembler cooperate in translating the statements for the binary machine. The difference between compilers and assemblers is that both are OS-specific. A compiler translates your high level source code into an executable file which is specific for your OS. For instance DOS can run MZ exes and *.com programs, win30 can run that and also NE executables, and windows 95 can run all of the ones before and also PE executables. An assembler translates low level source code into the above executables. Mostly the sequence of a compiler is that it translates first to assembly language which then is translated into an OS specific objectfile(*.obj or *.coff) by an assembler. The last step in making the runnable file is to statically link the object sources, which mainly involve relocating all labelreferences relative to the allocated segments. Remember though that the LAST step into making your executable run is the dynamic linking that the OS does to your programs. In single tasking environments like DOS that involves reading the info from a relativaly small header, allocating an arena for the program to play in, reading the whole program in memory and leaving the executable alone. In multitasking WINDOWS however much more has to be done. For one thing you never know for sure that the code is presently available in RAM. Windows uses a very difficult swapping policy which involves pagetables to decide which parts should be present. Another thing a windows program does is that is dynamically links all your consious and unconsious api references to the appropriate kernal vxds functions.

  Lots of discussion can be triggered about which languages, compilers and assemblers to use however. I won't do that. I just present my the set of free tools that I use, and that can at least compete on all dimensions I know with commercial products, being it from microsoft or watcom or borland or powerbasic. I don't say they are better, but one thing is for sure: the are all affordable, all activaly maintained and also heavily supported on usenet.

  1. DOS compilers

     QBASIC( interpreter)

     Never been beaten intrepreter for hands on experimenting with techniques and algorithms before the real work. Also the only exception to the above maintainance rule. QBasic hasn't been maintained for years by MS. Basic as a language is fairly limited, and thats why the only use for it is in quick experimentations. Nothing is as easy and fast for basic literates to type a few lines, run it, update it, etc etc. Basic is a procedural language which does not support OO.

     DJGPP(C++ compiler)

     c/c++ compiler which has all features to write big, and good programs. DJGPP is also used in a lot off university courses. C is the procedural language that you will see used most, also when it comes to showing algorithms and new technigues. If you want to stay in procedural programming you might also consider on off the free PASCAL compilers around.
     C++ is a language which supports OO by the implementation of virtual functions and inheretance. Both C and C++ are supported by DJGPP which is a 32 bit pmode compiler, which is to say it compiles to true 32 bit executables.

  2. Windows compilers

     RSXDJNT(Windows C++ compiler)

     c/c++ compiler for windows which is a compatible with DJGPP. It comes with its own version of ld.exe and djgpp.env so you probably have to write a batfile to toggle between the two versions. Other then that it also includes its own IDE, and there are no problems with using both djgpp and rsxntdj.

  3. Assemblers

     DEBUG

     Never been beaten debugger at assembly language level for hands on experimenting with assembly language. The first tool *a lot* of assembly language programmers used. Does not offer symbolic capacities however. I maintain a page which offers a syntax overview in html.

     VALARROW

     This is an assembler with symbolic capacities. Can be easily used to write small assembly language programs. I have been maintaining a page with features the learning of assembly language with the aid of this tool for a long time now. At that page you find the tools, specifications for the assembler, includefile for the stdlib for assembly programmers, links to assembly language pages and more.

     NASM

     If you really want to write big and 586 compatible assembly language programs you have only three choices: MASM which is no longer supported, TASM which has quite a few bugs and NASM which is a djgpp compatible assembler. NASM has its own syntax, and because I was already used to MASM syntax and also bought the product I still use MASM.

  LAST

  NEXT

• Libraries

  Libraries are very important in today's programming. In fact today's compilers are small, and include a runtime librarie which can be quit big themselves. Added to that there exist a lot of libraries, and especially in the sector of OO programming they are quit useful since its possible to let the old code in the librarie call new code(virtual librarie functions), to derive your own classes from baseclasses in a libraries(inheretance). The most useful way to use libraries however have been proven to be the use of templateclasses. In fact that much use was found for them that they have been included in the last C++ standard. For windowsprogramming you also simply can't do without windows specific libraries and include files.

  1. DOS specific libraries

     The standard librarie for assembly programmers

     When you really want to get into programming bigger programs in assembly language then you need a librarie. With the standard librarie you have a widely used tool which has all standard functions, as well as dynamic memory, list, coprocess support. Source is also available. In short:a must have

     Allegro

     Allegro is the great djgpp compatible graphix programming library that is still activally supported and built. It makes use of VESA modes, has built in support for double buffering, etc. etc. Especially for graphix and gameprogrammers probably one of the best libraries you can get. Activaly discussed at the djgpp newsgroup.

  2. Algorithm specific C++ libraries

     Standard template librarie(STL)

     Since a few months this librarie is even a part of "official c++". It turned out that programs in c++ made such a huge use of containers(essentially templated multiple variables) that it is pretty worthwile in terms of development time to have a librarie which supports the basic containers along with there algorithms. STL offers highly standarized support for about arrays, vectors, lists,deques,(multi)sets and (multi)maps, and there basic algorithms.

     Max Planck's algorithm librarie(LEDA)

     A slighly more specialized tool, which support a lot more algorithms like all kinds of optimized trees, heaps, lists and stacks. Of course it comes also with source..This is really a must have for probably everyone who makes big programs in c++.

  3. Windows libs, includefiles, apiref and tools

     Windows programming is clearly divided into layers. But for all of them MS designed a few depencies;-)

     Application level programming

     If you are programming for windows you absolutely need the original microsoft include files and apireference( which are in the basic setup), and also you can make very good use of the examples and tools microsoft offers. So: find out which is the nearest mirror site and at a quit time start loading all those zip files. Microsoft changes this pages every once in a very frequent while, but at this moment below is a working link to the dutch mirror of the PLATFORM SDK( as windows SDK is currently called).
     
     If you like to program for windows 95 then you might take part in discussion at:
     comp.os.ms-windows.programmer.win32 and microsoft.public.win32
     Watch out for the weekly posting in the comp group about win32 faqs, which lists a bundle of win32 programming faqs.

     Kernel level programming

     If you are interested in programming drivers for windows you absolutely need to look at the DDK part of the above ftp side. Even with books it is virtually impossible to know enough intimate details of windows without it. DDK contains a tutorial and tons of example VxDs. Also you must surely download the debug version of windows 95 from the above mentioned platformSDK, as well as a copy of the outstanding never been beaten often cracked softice for windows. Here is a link to the official softice site which used to offer a time limited version. If its not anymore be sure to get a cracked version from one of the cracking tools sites. You should get started at this. You might consider loading softice for DOS from the net somewhere too.
     
     While we are at it: for writing VxDs in c or c++ there is some very useful code on simtelnet:
     If you, as most will, rather like to write you VxD in assembly you might look at this example code VVMD.ZIP or alternativaly at a few of the samples from the original book about VxDs from Thielen and Woodruff: Writing Windows VxDs I have to admit I never made it to that ranks of VxD writers despite a lot of input so you will not see VxD code of mine below. However if you are interested enough I have two more advices:
     
     

     1. Sign up to the Dutch pmode list(language there is english of course) at
     2. Be sure to follow discussions at comp.os.ms-windows.programmer.vxd
        and maybe at microsoft.public.win32.programmer.kernel
        You can get lots of help from there. The comp. group has a nice . faq too.

  Walleg

  The transition of the graphix librarie allegro for the windows platform. A work in progress.. You can get it walleg

  • More libraries

    Libraries have become such an important part of a proffesional programmers tools that we might seriously doubt if programmers spend more time learning ins- and outs of compilers and platforms then they spend time in learning to use libraries. Really great libraries exist for about every programmable(and unprogrammable(like inductive learning)) problem. If you want to look a special librarie up the librarie faq might be a great start.

  • Documentation

    PS AND PDF viewer

    DVI viewer

    Making ps files

    A lot of the documentation which is either presented on this web page, or linked too from it, is in special formats. Some are using html with the addition of numerous graphics, some are using *.pdf and *.ps files, still others( most noteworthy gnu files) use *.dvi files which come as a byproduct of the translation of files for the info reader. Since printing out, and viewing documents which contain graphics in an easy way is essential for learning at a reasonable speed, I strongly urge you to download at least the gnu postscript viewers and printer files, but if you are using djgpp you might also consider to load the dvi packages. If you are that strongly into documentation that you want to produce *.dvi/*.ps files from text and graphics then you might look further into the tex directories of djgpp/gnu

  LAST

UP

NEXT