user13669: I don't know very much about chess beyond the rules but I enjoy programming and am trying to write a chess engine. I recently found this evaluation function: Simple Evaluation Function. What would be the best way to improve on what has been done there?

user13328: I would like to add up a couple things to support the good answers you    have already.

Stockfish never applies evaluation function for positions where king of
either side is in check.
Evaluation is based on the state of your Middle Game and End Game.
Also a smooth transition between the phases of the game using a fine 
grained numerical game phase value considering type of captured
pieces so far. This is called "Tapered Eval".

Here a snippet of my own evaluation for middle gale
EvalPhase middle_game_evaluation(&pos) {
  int ev = 0;
  ev += piece_value_mg(pos) - piece_value_mg(colorflip(pos));
  ev += psqt_mg(pos) - psqt_mg(colorflip(pos));
  ev += imbalance_total(pos);
  ev += pawns_mg(pos) - pawns_mg(colorflip(pos));
  ev += pieces_mg(pos) - pieces_mg(colorflip(pos));
  ev += mobility_mg(pos) - mobility_mg(colorflip(pos));
  ev += threats_mg(pos) - threats_mg(colorflip(pos));
  ev += passed_mg(pos) - passed_mg(colorflip(pos));
  ev += space(pos) - space(colorflip(pos));
  ev += king_mg(pos) - king_mg(colorflip(pos));
  return EvalPhase(ev);
}


user825: EDIT for comment
The most important by far is the material count and PST already discussed in your link. You won't go anywhere unless your engine can count materials properly. Other than that, the common knowledge such as rook behind a passed pawn, castled king, pawn majority and mobility are important. Your human knowledge to chess should be sufficient.
ORIGINAL
The best way to improve it is to study the Stockfish source code. Read the comments, and study the implementation.
Code your engine, make it work with a simple evaluation function. Gradually and slowly apply Stockfish's ideas to your own engine.
There's many possible improvements. I can only list some of those. I will give you a link to the Stockfish source code below.

Two bishops advantage
Interpolate between middle game and endgame scoring
Bonus to pawn structures (the page only gives very simple PST values) 
Calibrate the values better with a statistical model
Castled king
Number of squares controlled
Number of attacking squares near the enemy's king
Asymmetric evaluation (Stockfish doesn't do that but some engines like Chess Genius does that)
Pieces attacked by the king
Rook behind a pawn
Pawn on the check colour as bishop
Mobility bonus
Enemy checks
Rook on semi- or open file
Insufficient defended squares
Passed pawn that is not blocked
Candidate passed pawn (pawn majority)
......

Let's take some random examples from Stockfish. Please examine the source code yourself for details.

https://github.com/official-stockfish/Stockfish/blob/69eb391cd779223c331fb0de80392cbd323055a9/src/evaluate.cpp

// RookOnFile[semiopen/open] contains bonuses for each rook when there is no
// friendly pawn on the rook file.
const Score RookOnFile[] = { S(20, 7), S(45, 20) };

and
// ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
// which piece type attacks which one. Attacks on lesser pieces which are
// pawn-defended are not considered.
const Score ThreatByMinor[PIECE_TYPE_NB] = {
  S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
};

and
// Scale down bonus for candidate passers which need more than one
// pawn push to become passed or have a pawn in front of them.
if (!pos.pawn_passed(Us, s + pawn_push(Us)) || (pos.pieces(PAWN) & forward_bb(Us, s)))
        mbonus /= 2, ebonus /= 2;


13669: <p>I don't know very much about chess beyond the rules but I enjoy programming and am trying to write a chess engine. I recently found this evaluation function: <a href="https://chessprogramming.wikispaces.com/Simplified+evaluation+function" rel="noreferrer">Simple Evaluation Function</a>. What would be the best way to improve on what has been done there?</p>
 13328: <p>I would like to add up a couple things to support the good answers you    have already.</p>

<ul>
<li>Stockfish never applies evaluation function for positions where king of
either side is in check.</li>
<li>Evaluation is based on the state of your Middle Game and End Game.</li>
<li>Also a smooth transition between the phases of the game using a fine 
grained numerical game phase value considering type of captured<br>
pieces so far. This is called <a href="https://chessprogramming.wikispaces.com/Tapered+Eval" rel="nofollow noreferrer">"Tapered Eval"</a>.</li>
</ul>

<p>Here a snippet of my own evaluation for middle gale</p>

<pre><code>EvalPhase middle_game_evaluation(&amp;pos) {
  int ev = 0;
  ev += piece_value_mg(pos) - piece_value_mg(colorflip(pos));
  ev += psqt_mg(pos) - psqt_mg(colorflip(pos));
  ev += imbalance_total(pos);
  ev += pawns_mg(pos) - pawns_mg(colorflip(pos));
  ev += pieces_mg(pos) - pieces_mg(colorflip(pos));
  ev += mobility_mg(pos) - mobility_mg(colorflip(pos));
  ev += threats_mg(pos) - threats_mg(colorflip(pos));
  ev += passed_mg(pos) - passed_mg(colorflip(pos));
  ev += space(pos) - space(colorflip(pos));
  ev += king_mg(pos) - king_mg(colorflip(pos));
  return EvalPhase(ev);
}
</code></pre>
 825: <p><strong>EDIT for comment</strong></p>

<p>The most important by far is the material count and PST already discussed in your link. You won't go anywhere unless your engine can count materials properly. Other than that, the common knowledge such as rook behind a passed pawn, castled king, pawn majority and mobility are important. Your human knowledge to chess should be sufficient.</p>

<p><strong>ORIGINAL</strong></p>

<p>The best way to improve it is to study the Stockfish source code. Read the comments, and study the implementation.</p>

<p>Code your engine, make it work with a simple evaluation function. Gradually and slowly apply Stockfish's ideas to your own engine.</p>

<p>There's <strong>many</strong> possible improvements. I can only list some of those. I will give you a link to the Stockfish source code below.</p>

<ul>
<li>Two bishops advantage</li>
<li>Interpolate between middle game and endgame scoring</li>
<li>Bonus to pawn structures (the page only gives very simple PST values) </li>
<li>Calibrate the values better with a statistical model</li>
<li>Castled king</li>
<li>Number of squares controlled</li>
<li>Number of attacking squares near the enemy's king</li>
<li>Asymmetric evaluation (Stockfish doesn't do that but some engines like Chess Genius does that)</li>
<li>Pieces attacked by the king</li>
<li>Rook behind a pawn</li>
<li>Pawn on the check colour as bishop</li>
<li>Mobility bonus</li>
<li>Enemy checks</li>
<li>Rook on semi- or open file</li>
<li>Insufficient defended squares</li>
<li>Passed pawn that is not blocked</li>
<li>Candidate passed pawn (pawn majority)</li>
<li>......</li>
</ul>

<p>Let's take some random examples from Stockfish. Please examine the source code yourself for details.</p>

<blockquote>
  <p><a href="https://github.com/official-stockfish/Stockfish/blob/69eb391cd779223c331fb0de80392cbd323055a9/src/evaluate.cpp" rel="nofollow noreferrer">https://github.com/official-stockfish/Stockfish/blob/69eb391cd779223c331fb0de80392cbd323055a9/src/evaluate.cpp</a></p>
</blockquote>

<pre><code>// RookOnFile[semiopen/open] contains bonuses for each rook when there is no
// friendly pawn on the rook file.
const Score RookOnFile[] = { S(20, 7), S(45, 20) };
</code></pre>

<p>and</p>

<pre><code>// ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
// which piece type attacks which one. Attacks on lesser pieces which are
// pawn-defended are not considered.
const Score ThreatByMinor[PIECE_TYPE_NB] = {
  S(0, 0), S(0, 33), S(45, 43), S(46, 47), S(72, 107), S(48, 118)
};
</code></pre>

<p>and</p>

<pre><code>// Scale down bonus for candidate passers which need more than one
// pawn push to become passed or have a pawn in front of them.
if (!pos.pawn_passed(Us, s + pawn_push(Us)) || (pos.pieces(PAWN) &amp; forward_bb(Us, s)))
        mbonus /= 2, ebonus /= 2;
</code></pre>
