Upcoming Events
Unite 2010
11/10 - 11/12 @ Montréal, Canada

GDC China
12/5 - 12/7 @ Shanghai, China

Asia Game Show 2010
12/24 - 12/27  

GDC 2011
2/28 - 3/4 @ San Francisco, CA

More events...
Quick Stats
39 people currently visiting GDNet.
2406 articles in the reference section.

Help us fight cancer!
Join SETI Team GDNet!
Link to us Events 4 Gamers
Home » Articles & Resources » Programming » General Programming
Intel sponsors gamedev.net search:
General Programming

Here you will find articles about algorithms, optimization, and other subjects not specific to game programming.

For more information about General Programming, check out:

Resources Listed: 98
Compression AlgorithmsData Structures
Sorting Algorithms 
Subcategory: Compression Algorithms
Topic Author Description
16-bit RLE Compression
[Added: 7/16/1999]
Shaun Case  Explains the RLE compression algorithm and file format. 
8--bit RLE Compression
[Added: 7/15/1999]
Shaun Case  8 bit version of the other article. 
Arithmetic Compression
[Added: 7/16/1999]
ARJ Extractor
[Added: 7/15/1999]
Compression FAQ - Part 1
[Added: 7/16/1999]
Compression FAQ - Part 2
[Added: 7/16/1999]
Compression FAQ - Part 3
[Added: 7/16/1999]
Data Compression Algorithms of LARC and LHarc
[Added: 7/16/1999]
Haruhiko Okumura  Covers a number of compression algorithms, including LZSS, LZW, Huffman, Arithmetic, LZARI, and LZHUF. 
Huffman Compression
[Added: 7/16/1999]
In Memory Data Compression and Decompression
[Added: 12/12/2005]
Lee Millward  Shows how to perform compression and decompression between data buffers in memory using the zlib library. 
Limpel-Zive Algorithm
[Added: 7/16/1999]
LZW Compression Algorithm
[Added: 7/16/1999]
Simple Compression using an LZ Buffer
[Added: 7/16/1999]
Subcategory: General
Topic Author Description
20 issues of porting C++ code on the 64-bit platform
[Added: 10/3/2007]
Andrey Karpov, Evgeniy Ryzhkov  The article observes some questions related to testing the 64-bit software. Some difficulties which a developer of resource-intensive 64- bit applications may face and the ways to overcome them are described 
A Case for Code Review
[Added: 4/11/2000]
John Stenersen  Discusses how code review can lead to gains for your entire development team and product lines. 
Algorithmic Forays Part 1
[Added: 3/7/2004]
Eli Bendersky  The first installment in this series takes a look at the Finite State Machine. 
Algorithmic Forays Part 2
[Added: 3/29/2004]
Eli Bendersky  This installment looks at regular expressions. 
Algorithmic Forays Part 3
[Added: 4/28/2004]
Eli Bendersky  Introduces DFAs and NFAs, and explains the differences between them. 
Algorithmic Forays Part 4
[Added: 6/7/2004]
Eli Bendersky  Continues the exploration of DFAs and NFAs. 
Algorithmic Forays Part 5
[Added: 8/17/2004]
Eli Bendersky  The article discusses and implements the process of taking an arbitrary regex and automatically converting it into an NFA. 
Algorithmic Forays Part 6
[Added: 11/4/2004]
Eli Bendersky  This installment covers converting NFAs to DFAs. 
Algorithmic Forays Part 7
[Added: 1/29/2005]
Eli Bendersky  Discusses memoization – a technique to speed up recursive computations. 
Algorithmic Forays Part 8
[Added: 5/2/2005]
Eli Bendersky  This installment describes what caches are, why they are useful, and how to implement one in software. 
Application port to 64-bit platforms
[Added: 9/12/2007]
Vladimir Elesin  So, is it really necessary to port the applications to the 64-bit platforms? And if the decision of the porting is made, then by what means can it be done with the least time and financial costs? 
Basic Encryption
[Added: 12/15/2001]
Matt Recker  Covers the essentials involved with encryption. 
Bitwise Operations in C
[Added: 10/30/2001]
Joseph Farrell  Explains in detail what the various bitwise operations are, and shows examples of how they are used in game programming. 
Distributing Your Games
[Added: 10/14/2003]
Rob Segal  Takes a look at the tools available to create installation packages. 
Do You Really Mean Rotation?
[Added: 9/27/2007]
Stan Melax  This article is a light discussion of the term 'rotation' as sometimes used in the game development industry. Focuses on programming practices and illustrates the importance of naming variables carefully 
Driver Development for Windows 64-bit
[Added: 9/12/2007]
Evgeniy Ryzhkov  Questions concerned with the release of drivers for 64-bit versions of Windows are considered in this article. Some typical problems and the ways of their solutions are listed in the article as well as tools which simplify the process of drivers developing. 
Elements of Programming Style -- The C++ Style Guide
[Added: 9/13/1999]
Neill Kipp  This is a well-written guide to what the author considers good C++ coding style.  
Evaluating Java for Game Development
[Added: 6/26/2000]
Jacob Marner  Dispels many of the common myths about Java's suitability to games. 
Frame Rate Independent Movement
[Added: 6/4/2001]
Ben Dilts  Explains how to keep game objects moving at the same rate independently of the frame rate. 
How Pointers Really Work
[Added: 8/28/2000]
OutAxDx  If you're having trouble understanding pointers, this could help you out. 
Implementing 2D Vectors
[Added: 5/21/2000]
Willem van Doesburg  A vector implementation in C++. 
Improving Software Performance
[Added: 7/31/1999]
Edward T. Smith  Regardless of any programmer’s experience and expertise, there is always a potential for performance improvements. Performance critical software should always be analyzed for bottlenecks and poorly written code.  
Introduction to Debugging
[Added: 6/19/2006]
Richard "superpig" Fine  An extensive introduction of the debugging process including the tools used. 
Introduction to Linked Lists
[Added: 1/19/2001]
Shadow Mint  Provides a basic explanation of a very useful data structure. 
Introduction to Pointers, Structures and Linked-Lists Part 1
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to pointers 
Introduction to Pointers, Structures and Linked-Lists Part 2
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to structures (and typedefs) 
Introduction to Pointers, Structures and Linked-Lists Part 3
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to simple linked-lists 
Introduction to Pointers, Structures and Linked-Lists Part 4
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to dynamic memory allocation 
Introduction to Pointers, Structures and Linked-Lists Part 5
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Sorting 
Introduction to Pointers, Structures and Linked-Lists Part 6
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to recursion 
Introduction to Pointers, Structures and Linked-Lists Part 7
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to member functions 
Introduction to Pointers, Structures and Linked-Lists Part 8
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Introduction to classes 
Introduction to Pointers, Structures and Linked-Lists Part 9
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Class design 
Introduction to Pointers, Structures and Linked-Lists Part 10
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Brief introduction to inheritance 
Introduction to Pointers, Structures and Linked-Lists Part 11
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Brief introduction to polymorphism 
Introduction to Pointers, Structures and Linked-Lists Part 12
[Added: 9/30/2004]
Chris Bennett aka Dwarfsoft  Brief introduction to operator overloading 
Low Latency Garbage Collection via Reference Counting
[Added: 6/19/2000]
Photon  Presents a method for freeing dynamically allocated memory that is is no longer in use, that is useful in handling normal game data. 
Making Your Libraries Release-Friendly
[Added: 10/15/2003]
Sobeit Void  Presents some tips for distributing your libraries to make them more user-friendly. 
Mersenne Twister random number generator
[Added: 1/15/2002]
  Another random number generator that's superior to rand(). This one claims to be four times faster and is implemented in several computer languages. 
Modular Programming: A Classless Approach Part I
[Added: 6/24/2000]
Dan Arson  This series looks at approaches to modular programming in C/C++ without using C++ classes. In part I, the author presents an alternative method for multiple object instances. 
Motor Skill Learning in User Interfaces via Discretized Pie Menus
[Added: 4/13/2005]
Jonathan H. K. Mak  Presents discretized pie menus as an alternative to pointer-based interfaces. 
One Layer XOR Based Encryption
[Added: 1/11/2002]
Kurifu Roushu  Provides a basic overview of encryption using a single key and the XOR operator. 
Orphans Preferred
[Added: 7/10/2000]
Steve McConnell  Takes a look at how much of the programmer stereotype is really true, and what effect it has on the programming occupation. 
Peculiarities of the Development of 64-bit Applications
[Added: 9/12/2007]
Evgeniy Ryzhkov  What did programmers get when 64-bit systems came to power? Besides the numerous advantages described in many advertising articles, programmers got the whole bunch of brainteasers, puzzles and even traps. Everyone who wants to get real advantages of using 64-bit systems has to face these ones 
Pillars of Good Programming
[Added: 11/23/1999]
TANSTAAFL  Crucial reading for anyone who wants to be a real programmer. 
Problems of testing 64-bit applications
[Added: 9/12/2007]
Andrey Karpov  The article observes some questions related to testing the 64-bit software. Some difficulties which a developer of resource-intensive 64-bit applications may face and the ways to overcome them are described. 
Putting it all together: How to best arrange C++ source and header files
[Added: 11/4/2000]
Ben Dilts  Covers the basics of what you need to do to share globals across multiple files. 
Random Name-Generation Using Grammars
[Added: 11/24/2003]
Constantin Christmann  Demonstrates a method for building reasonable names using grammars, with pronouncibility guaranteed. 
Reducing Flicker in Console Applications
[Added: 5/18/2009]
Mike Gassman  This quick tip will show you how to properly clear a screen in a console window to update it without flickering 
Rules for Parallel Programming for Multicore
[Added: 9/17/2007]
James Reinders  eight key rules for multicore programming based on parallel programming experiences of the author's own and others 
Simple Event Handling
[Added: 9/16/2004]
Yacine Salmi  Presents a basic event handling module, with source code included. 
Software Engineering is Not Computer Science
[Added: 7/10/2000]
Steve McConnell  In this excerpt from After the Gold Rush, McConnell makes the distinction between software engineering and computer science, and discusses the implications of that distinction on the software industry. 
SQL in 60 Seconds
[Added: 9/28/2003]
Albert "thec" Sandberg  Provides a convenient introduction to SQL. 
Static Library Tips
[Added: 11/1/2001]
Sobeit Void  Provides suggestions for improving the efficiency and correctness of static libraries. 
String Usage and Architecture
[Added: 3/10/2004]
Andy Oxfeld  Covers many aspects of working with C-style strings. 
The Art of Code Documentation
[Added: 10/18/2000]
Drew Sikora  Think comments aren't important? Think again. This article will show you why you should document your code, and give you some guidelines for doing it. 
The Cost of Insecurity - Griefing: from Anonymity to Accountability
[Added: 4/21/2005]
Steven B. Davis  Defines griefing and discusses how security solutions can be used to detect it.  
Tips for Cross-Platform I/O in C/C++
[Added: 5/3/2005]
John Bolton  A brief list of useful tips. 
Understanding Data Structures Part 1 : Linked Lists
[Added: 6/28/2000]
Kevin Hawkins  Part I of this series explains and provides an implementation of the linked list, as well as reviewing pointers and memory allocation. 
Using an RTF Log File
[Added: 4/12/2004]
Eamonn Doherty  Describes how to use the RTF format for logging, and provides a complete implementation you can use. 
Using Function Pointers
[Added: 7/1/2004]
Jason Mickela  Describes how to use function pointers in various ways to increase the performance and readability of your code. 
Visual Studio Macros for the Game Programmer
[Added: 11/12/2007]
Mike Cline  A look into VS macros, with some examples of useful macros 
VSIP: Detecting code window switches in VS 2005
[Added: 5/25/2007]
Scott H, SlickEdit  A look at the problem of reliably detecting code window lifecycle changes in Visual Studio 2005 using the VSIP SDK 
Whatever Happened to Reuse?
[Added: 7/10/2000]
Steve Adolph  Looks at why code reuse isn't as widespread as it could be. 
Writing Endian Independent Code in C++
[Added: 4/27/2004]
Promit Roy  Explains what endian means and shows how to write code to deal with it. 
Writing Readable Code
[Added: 10/21/1999]
Brent P. Newhall  The article focuses on how to write "good" code, in particular focusing on code that's readable and easy to maintain.  
Zero-Defect Software Development
[Added: 6/13/2000]
Steve Pavlina  Describes a practice of developing software that is maintained in the highest quality state throughout the entire development process. 
Subcategory: Sorting Algorithms
Topic Author Description
Bubble Sort
[Added: 7/16/1999]
Comparison Of Sorting Algorithms
[Added: 7/16/1999]
Elementary Sorting Techniques
[Added: 7/16/1999]
[Added: 9/13/1999]
Yin-So Chen  The heapsort is a very dependable in-place sorting algorithm, with a rate of growth of O (n log n). Though not quite as fast as quicksort, it has no worst-case scenario. 
Insertion Sort
[Added: 9/13/1999]
Yin-So Chen  Insertion sort can run in O (n) in the best case, however its worst case is O (n2). It can, however, be used to optimize the quicksort, and is therefore worth learning. 
[Added: 9/13/1999]
Yin-So Chen  The quicksort is the fastest known comparison-based sorting algorithm, with a growth rate of O (n log n) on average. However, in the worst case, this degrades to O (n2), but this can be mostly avoided if implemented carefully. 
Radix Sort
[Added: 9/13/1999]
Yin-So Chen  The radix sort is not as versatile as some others, but it runs in linear - O (n) - time. 
Shell Sort
[Added: 9/13/1999]
Yin-So Chen  Shell sort modifies the insertion sort algorithm and avoids its worst-case behavior. 
Shell Sorting
[Added: 7/16/1999]
Understanding the QuickSort Algorithm
[Added: 6/28/2000]
Joe Farrell  Provides an implementation and explanation of the quicksort algorithm. 
Subcategory: Data Structures
Topic Author Description
An Introduction to Hash Tables with Chaining
[Added: 3/16/2004]
GaulerTheGoat  Provides an introduction to and implementation of chained hash tables. 
Back to Basics: Stacks
[Added: 9/4/2007]
Steven Phung  A short and simple view of the stacks data structure for beginners looking to grasp the basic concepts 
Balanced binary search tree with a doubly linked list in C++
[Added: 7/7/2004]
Arjan van den Boogaard  Presents a modification to red-black trees allowing duplicate entries with a fast ordered traversal. 
Trees Part 1
[Added: 5/27/2001]
Ron Penton  Presents an introduction to the tree data structure, and provides an implementation of a general purpose tree. 
Trees Part 2: Binary Trees
[Added: 6/28/2001]
Ron Penton  Extensively covers binary trees, including binary search trees, and how to work with them. 
Using Linked Lists to Represent Game Objects
[Added: 1/13/2004]
Jackson Allan  Explains how to use linked lists in the context of a game. 
Using Managers
[Added: 5/29/2002]
Ebor Folkertsma  Discusses the use of a templated, singlton manager class for handling data. 
Subcategory: Links
Name Rating Description
Sorting and Searching Algorithms: a Cookbook
[Added: 5/17/2000 Clicks: 13178]
If you need to sort, go here. Discusses several sorting algorithms and their relative merits (or lack thereof). Very well illustrated. Also includes some bonus documentation on hash tables and trees. 
 Key: = HTML article hosted here  , = HTML article hosted elsewhere  = link to another web site  = Adobe Acrobat document  = Zip files  = Word or text document