GameDev.net -- General Programming

Home » Articles & Resources » Programming » General Programming

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:

Our General Programming books.
Our General Programming forum.

Resources Listed: 98

Jump To :
Compression Algorithms	Data Structures
General	Links
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]
	Heapsort [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 (n²). It can, however, be used to optimize the quicksort, and is therefore worth learning.
	Quicksort [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 (n²), 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