1: //needed for printf()

   2: #include <stdio.h>

   3:  

   4: //needed for strlen()

   5: #include <string.h>

   6:  

   7: // prints the contents of memory in hex and ascii.

   8: // starts at the location of the pointer "start"

   9: // prints "length" bytes of memory.

  10: void Print_Memory(const unsigned char * start, unsigned int length)

  11: {

  12:     //create row, col, and i.  Set i to 0

  13:     int row, col, i = 0;

  14:  

  15:     //iterate through the rows, which will be 16 bytes of memory wide

  16:     for(row = 0; (i + 1) < length; row++)

  17:     {

  18:         //print hex representation

  19:         for(col = 0; col<16; col++)

  20:         {

  21:             //calculate the current index

  22:             i = row*16+col;

  23:             

  24:             //divides a row of 16 into two columns of 8

  25:             if(col==8)

  26:                 printf(" ");

  27:             

  28:             //print the hex value if the current index is in range.

  29:             if(i<length)

  30:                 printf("%02X", start[i]);

  31:             //print a blank if the current index is past the end

  32:             else

  33:                 printf("  ");

  34:             

  35:             //print a space to keep the values separate

  36:             printf(" ");

  37:         }

  38:         

  39:         //create a vertial seperator between hex and ascii representations

  40:         printf(" ");

  41:  

  42:         //print ascii representation

  43:         for(col = 0; col<16; col++)

  44:         {

  45:             //calculate the current index

  46:             i = row*16+col;

  47:             

  48:             //divides a row of 16 into two coumns of 8

  49:             if(col==8)

  50:                 printf("  ");

  51:             

  52:             //print the value if it is in range

  53:             if(i<length)

  54:             {

  55:                 //print the ascii value if applicable

  56:                 if(start[i]>0x20 && start[i]<0x7F)  //A-Z

  57:                     printf("%c", start[i]);

  58:                 //print a period if the value is not printable

  59:                 else

  60:                     printf(".");

  61:             }

  62:             //nothing else to print, so break out of this for loop

  63:             else

  64:                 break;

  65:         }

  66:         

  67:         //create a new row

  68:         printf("\n");

  69:     }

  70: }

  71:  

  72: // Prints the contents of memory in hex and ascii.

  73: // Prints the memory between and including the

  74: // two "end1" and "end2" pointers.

  75: void Print_Memory(const unsigned char * end1, const unsigned char * end2)

  76: {

  77:     if(end2 >= end1)

  78:         Print_Memory(end1, end2 - end1 + 1);

  79:     else

  80:         Print_Memory(end2, end1 - end2 + 1);

  81: }

  82:  

  83: int main(int argc, char **args)

  84: {

  85:     const char start [] = "hi there!  You're looking at me in memory!";

  86:     const char * end = start + (int)strlen(start);

  87:  

  88:     Print_Memory((unsigned char *)start, (unsigned char *)end);

  89:  

  90:     return 0;

  91: }

I’ve compiled this code with both g++ and Visual C++.

download here

Here is the program’s output:

68 69 20 74 68 65 72 65  21 20 20 59 6F 75 27 72  hi.there  !..You'r
65 20 6C 6F 6F 6B 69 6E  67 20 61 74 20 6D 65 20  e.lookin  g.at.me.
69 6E 20 6D 65 6D 6F 72  79 21 00                 in.memor  y!.

When I was little, I was fascinated by what I now know are the break lights that are in the rear window of most cars.  When it was nighttime and we came to a stoplight, I noticed how even though I couldn’t see that the stoplight itself was red, there was a correlation between the stoplight being red and the red light in the rear window of the car in front of us.  I wondered by what mechanism the car in front of us knew that the light was red, and thought that it was very useful for cars to relay that information to the cars behind them.

I know now that the key element in making that happen was the driver tapping on the breaks, and in fact the light didn’t signify anything directly about any stop light, just that the driver had his foot on the break pedal.  Even so, I have always been interested in what makes technology tick, and (even more) how to design something that has some kind of interactivity or pseudo intelligence.  To me, code is a form of magic—now hear me out!

When I write a program, I pull the words out of nowhere.  I can take an idea, describe how a program should behave, and it will simply happen.  I said that this was like magic, but now let me step back a bit.  To me code lets me perform a kind of magic that applies to the virtual world rather than the physical, with a bit of crossover via different kinds of human-computer interaction.  The kind of magic that code can accomplish applies to information rather than physical objects.  For example, the idea of someone seeing something and capturing that moment to be displayed on a picture frame in his grandparents’ house is whimsical at least—without any explanation anyway.  However, with a digital camera, an Eye-Fi wireless SD card, and an appropriate digital picture frame, one could take a picture, the Eye-Fi could find an open wifi hotspot, connect to Flickr, and upload the picture for the digital picture frame to download and display.

Did you just yawn there?  Most people would, but that’s kind of the point.  Technology can accomplish amazing things—the sky is hardly the limit.  When dreaming up an idea, it isn’t always important to have it seem realistic at first.  Furthermore, no matter how cool the demo, the actual magic will come down to bits and bytes… but that’s great!  To me, in creating software, the biggest barriers are knowledge, skill, and time.  With those three things one person could create a software product that works better than a similar product by a big company.  Two identical pieces of hardware could be made vastly different with different software.  Firmware updates for portable devices are a good example of this, as are videos games for any given console.  On a console, every development team has the same canvas to work with, and it is amazing to see the wildly varied experiences that different games can create.

I’ve always been facinated by this stuff, and always will be.  That’s great for me, though, because it’s an inexpensive hobby and a well-paying profession.  Ah, I think I’ll write a bit of code right now.

I have a friend who is an open-source fiend, and so he nag nag nagged me to make the source code  for FRI available for download.  After a lot of re-organizing and commenting, here it is!  The "Frie" project in the Visual Studio solution is the FRI back-end, stands for "Fantastic ROM Indexer Engine".  Yes, it is pronounced "free" just like the front-end.

I’m putting this code out on the Internet, but please keep in mind that FRI is still my baby.  If you want to make a derivative work, email me first for permission.

Download FRI Version 1.5.0.0 Source Code here

Change Log:

• Fix: emulator compatibility is now caps-insensitive
• Fix: emulator selector centered and has correct icon
• Re-Write: Emulator loader re-written.  The emulator selector now looks finished.  Note that ROMs can no longer be opened in bulk.
• New Feature: Image Health (good dump, bad dump) can now be searched.
• New Feature: The default size of the Advanced Search window is now just the right size to fit all of the content.
  
• New Feature: The default size of the Emulator Selector window is not just the right size to fit all of the content.
  Here is the Emulator Selector when I select a PlayStation ROM to play. (I don’t have any PlayStation emulator configured to work with FRI, so it just shows all of the emulators.)
  
  Here is the Emulator Selector when I select a Game Boy ROM to play.  Since I have more than one Game Boy-compatible emulator configured in FRI, it gives me a choice.
   
• New Feature:  More-detailed status messages in the status bar.
  
• Tweak:  Many improvements to program responsiveness.  Previous versions of FRI freeze temporarily when scanning for a large number of new ROMs, or when populating the ROM list when a large number of ROMs.  Various tweaks, combined with the new status bar messages, ensure that FRI remains responsive and keep the user in control.
• New Feature: Maximum number of players can now be an implied meaning of a File Tag.  This means that if a ROM has "[p1]" in the file name, then FRI will recognize it as a 1-player game.  As always, the user can create new tags, so if the user has a lot of ROMs with "(1 player)" denoting that it is a 1-player ROM, then he can easily add that to the File Flag Vocabulary.
  
• New Feature:  FRI now has the ability to randomly-select a ROM in the ROM-list, or (if multiple ROMs are already selected) to randomly-select a ROM out of the selected ROMs.
  
• New Feature: Now when FRI is closed it only saves the database if changes have been made.
  

The first challenge was to figure out how to calculate π.  I came up with this website.  I decided to use “Gregory’s Formula” at the bottom of the page, which is an alternating series.

Here’s what I saw on the website:

So that means that…

and finally…

The last equation is just the calculus version of the first one.  In either way the basic pattern is that I start with 1/1, subtract 1/3, add 1/5, and so on.  Then at whatever point I want multiply that resulting summation by 4 to get an approximation of π.  The fun part is translating that into code.

So what does that look like in code? Well, I made a whole PiCalculator class, but this is the part that runs over and over:

And whenever Pi is requested, it just multiplies aFourh by 4.

That’s the basic idea.  There’s more code to initiate the calculation process (and run it on a separate thread), a bunch of accessors so that the main program can get information to display, and finally there’s code to actually display all of the information.

When the program is first opened it looks like this:

It’s calculating π in the background, but for performance sake it only shows the user the values when the “Update” button or enter is pressed.

After 30 seconds it has more pi than any sane person would care about.

One thing I had to look out for was numbers that were too extreme.  Eventually that fraction that is being added and subtracted in the summation is going to be rounded to zero, so I account for that in the code, stopping the calculations in that event.  As you can see, though, even with my computer’s Intel Core 2 Quad Q660, I would have to run this program for several years to have that happen.

So this was a fun little project.  Feel free to try it out for yourself!

Download the executable here

Download the C# source code here