user30311: I want to store a few (8 as of now) IR codes into my Board's EEPROM.
It would be great if someone could suggest a few tips to maximize the lifetime.
The IR codes in my sketch are saved in array of unsigned longs.
I know that the count of times that I will be writing to EEPROM will << 100,000 times, but still would like to optimize my sketch. + would help in future projects

user13327: If your data occupies only a small fraction of your EEPROM, you could use one of the wear leveling algorithms. The essence of these algorithms is to write to a different location each time, so writes are spread across several locations while each location stays below the 100,000 writes limit.
There are several such algorithms discussed here, which you could implement yourself. Alternatively, you could just use a library like this one.

user30005: I can think of a few:

don't power it on unless you have to;
don't write to it unless you have to;
write as little data to you as you can - compress the data; only write to it during brown out or power down, ...;
level the writes to as many cells as possible - increment the write address with subsequent writes;
use a big eeprom;
use fram;
use sram + battery back-up;

...
3 - 7 are really examples of implementating #2.

user3917: The other answer mentioned some general ideas; here are a couple of more-specific notes.
• You can direct your writes of single bytes through a routine that reads the EEPROM cell before writing to it, and if its value isn't changing, doesn't write.
• For load-leveling, you can divide the EEPROM address space into k buckets, where k =⌊E/(n+1)⌋, with n = data array size and E = EEPROM size.  Initialize a directory, an array of m bytes all set to k, with m = E-n·k.  When your device starts up, it reads through the directory until it finds current entry, a byte not equal to k. [If all directory entries equal k, initialize the first to 0, and go on from there.]  If the current directory entry contains j, then bucket j contains current data.  When you need to write new data, you store j+1 into the current directory entry; if that makes it equal to k, initialize the next directory entry to 0, and go on from there.  Note that directory bytes get about the same amount of wear as bucket bytes because 2·k > m ≥ k.  

30311: <p>I want to store a few (8 as of now) IR codes into my Board's EEPROM.
It would be great if someone could suggest a few tips to maximize the lifetime.</p>

<p>The IR codes in my sketch are saved in array of unsigned longs.</p>

<p>I know that the count of times that I will be writing to EEPROM will &lt;&lt; 100,000 times, but still would like to optimize my sketch. + would help in future projects</p>
 13327: <p>If your data occupies only a small fraction of your EEPROM, you could use one of the <a href="https://en.wikipedia.org/wiki/Wear_leveling" rel="nofollow noreferrer">wear leveling</a> algorithms. The essence of these algorithms is to write to a different location each time, so writes are spread across several locations while each location stays below the 100,000 writes limit.</p>

<p>There are several such algorithms discussed <a href="https://arduino.stackexchange.com/questions/16663/how-do-you-write-to-a-free-location-on-an-external-eeprom">here</a>, which you could implement yourself. Alternatively, you could just use a library like <a href="https://github.com/PRosenb/EEPROMWearLevel/" rel="nofollow noreferrer">this one</a>.</p>
 30005: <p>I can think of a few:</p>

<ol>
<li>don't power it on unless you have to;</li>
<li>don't write to it unless you have to;</li>
<li>write as little data to you as you can - compress the data; only write to it during brown out or power down, ...;</li>
<li>level the writes to as many cells as possible - increment the write address with subsequent writes;</li>
<li>use a big eeprom;</li>
<li>use fram;</li>
<li>use sram + battery back-up;</li>
</ol>

<p>...</p>

<p>3 - 7 are really examples of implementating #2.</p>
 3917: <p>The other answer mentioned some general ideas; here are a couple of more-specific notes.</p>

<p>• You can direct your writes of single bytes through a routine that reads the EEPROM cell before writing to it, and if its value isn't changing, doesn't write.</p>

<p>• For load-leveling, you can divide the EEPROM address space into k buckets, where k =⌊E/(n+1)⌋, with n = data array size and E = EEPROM size.  Initialize a directory, an array of m bytes all set to k, with m = E-n·k.  When your device starts up, it reads through the directory until it finds current entry, a byte not equal to k. [If all directory entries equal k, initialize the first to 0, and go on from there.]  If the current directory entry contains j, then bucket j contains current data.  When you need to write new data, you store j+1 into the current directory entry; if that makes it equal to k, initialize the next directory entry to 0, and go on from there.  Note that directory bytes get about the same amount of wear as bucket bytes because 2·k > m ≥ k.  </p>
