GameDev.net -- General

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.