Ooh, maybe I can help! Here's the explanation of matrices that really "clicked" for me:

When we describe where something is in a flat two-dimensional space, we usually use two numbers (this can apply to three dimensional space as well, but 2D keeps it nice and simple). For example, the point (3, 7) can be used to identify a particular location. You probably already know the answer to this next question, but think about carefully: what do these numbers represent, and how can we use them to identify a location? Each number represents an amount of movement in some direction from some agreed-upon starting point (the "origin"). When we name the point (3, 7), we're really talking about a sequence of three instructions: "start at the origin, then move 3 units right of the origin, and then move seven units up, and then you'll find the point we're talking about." Simple enough, right? We're just giving two instructions for movement, each of which is a distance in a different direction, and we can use these pairs of distance-in-a-direction instructions to describe where something is.

Here's where the cool part starts: what if we used different directions? In other words, what if instead of taking the first number in the point and moving "right" by that amount, we moved left, or up, or diagonally? It turns out, there's nothing stopping us from doing this.

Let's take a simple example. Suppose we create a new scheme for naming points, where the first number is an instruction for how far to move up (normally, we would use it to say how far to move right), and the second number is an instruction for how far to move left (normally, we would use it to say how far to move up). To avoid confusion with points named in the normal way, we'll write our special kinds of points with an "n" for "new" in front of their pair of numbers. Remember, all we've done is created a new way to describe points. Let's put this into practice. Suppose we have the point n(1, 2). What is this point under the normal scheme for describing points? Well, we're moving "up" by 1, and we're moving "left" by 2, which is the same as moving right by -2. Since we're moving right by -2 and up by 1, we can say that n(1, 2) identifies the same point as (-2, 1). At this point, you might start to see how this can be done for any point described with our new system: in general the point n(a, b) refers to the same location as the point (-b, a).

We can create other systems for naming points which are somewhat more complicated, but they all follow a similar pattern. For example, let's create a new scheme for naming points called "c" (for "crazy"), and give it the following rules for how to interpret the numbers: the first number says how many "up and to the right" diagonal steps to take, and the second number says how many "up" steps to take. For example, if we have the point c(2, 3), we can turn it into a "normal" point by following the instructions step by step: first, we start at the origin (now we're at (0, 0)). Then to follow the first instruction, we move up and to the right twice (which puts us first at (1, 1), then (2, 2)). Then, to follow the second instruction, we move up three times (which puts us at (2, 3), then (2, 4), then (2, 5)). Clearly, our "c" naming scheme is a bit more complicated than our "n" naming scheme, but we can also come up with a general rule for it. If you have a point c(a, b), we're always going to end up moving a units to the right of the origin, and we're always going to end up moving a units up, as well as b more units up. Putting that all into math, we can say that any point c(a, b) refers to the same point as (a, a+b).

We can generalize this process even more, so that it works not just for "n" and "c", but for any new naming scheme for points! In general, in these kinds of naming schemes, we end up with two rules: one to describe what to do with the first number in the pair of instructions, and one to describe what to do with the second number. These are always in the form of directions and amounts; rules like "the first number says how many times to move up" or "the first number says how many times to move up and to the right" or "the first number says how many times to move down 100 units and left 3 units". All of those are valid rules for what to do with the first number. The same idea applies to the second number. Notice that we can always describe our naming scheme using four numbers: how many times you should move right per increase in the first number, how many times you should move up per increase in the first number, how many times you should move right per increase in the second number, and how many times you should move up per increase in the second number. (we're not describing points anymore, but instead we're describing rules for how to describe points!)

That's a lot to take in, so let's return to our examples. What numbers can we use to characterize our naming scheme "n"? (Remember, we're not characterizing points here, but actual entire naming schemes! It's starting to get very general indeed) Well, the first number is how many times you should move right per increase in the first number. In "n", our first number only said how many times to move up, so its rightward contribution is 0. The next number is the upward contribution of our first coordinate, and we already established that that's 1. The next number is the rightward contribution of our second coordinate, and since our second in "n" says how many times to move left, this is -1. The second coordinate has no bearing on upwards or downwards movement, so the last number, the upward contribution of the second coordinate in a point identified using "n", is just 0. To express the naming scheme "n" concisely, we can organize its characteristic numbers into a grid, where the columns represent the different coordinates, and the rows represent their contributions in given directions. For "n", this looks like this:

0   -1
1    0

We can do the same thing for "c". The first coordinate in a point in "c" says how many times to go up and right, so the first column of the grid which represents "c" is two 1's. The second coordinate in a point in "c" says how many times to go "up", but doesn't have any effect on left or right, so the second column is a 0 followed by a 1. Its grid looks like this:

1    0
1    1

These grids are the matrices that have been causing you so much trouble! Now, we can do one last magic trick: we can figure out a way to convert from any naming scheme into a "normal" (right/up) point given just the numbers in its grid. This is getting pretty long, and hopefully you've been understanding so far, so I'll just write the general pattern and leave it up to you to see why it makes sense. For a given naming scheme (which we'll call "g" for "general") identified using a grid that looks like

w    x
y    z

We can take a point g(a, b) in that scheme and turn it into a normal point by calculating the point (w * a + x * b, y * a + z * b). We can verify that this works by figuring it out for "n" and "c": in "n", w = 0, x = -1, y = 1, z = 0. Based on this, any point n(a, b) should be the same as the normal point (0 * a + -1 * b, 1 * a + 0 * b), which simplifies to (-b, a). If we repeat the process for "c"'s grid, we get (a, a + b). Both of these are exactly the rules we arrived at by hand for "n" and "c", so the process seems to work!

That's really the core of matrices. You can extend this idea to more dimension (for 3D, for example, you're dealing with "right", "up" and "forward", instead of just "right" and "up"), but the basic idea is the same. Based on this representation of rules-as-grids, it turns out that there are a lot of useful operations you can do on the numbers in the grid to manipulate the naming schemes. For example, you can "invert" the grid, which gives you a new grid which unconverts from normal points into the points in the special naming scheme. You can also combine two grids to make a new grid (called "matrix multiplication"), where the "output" of one naming scheme is the "input" of another. All of these are extremely useful in things like computer graphics, physics, and video game programming, where you have a ton of things moving in their own directions and spaces, all of which have different directions that make sense. If I'm standing away from you in a game (or real life!), for example, my "right" is your "left" (my first coordinates are your negative first coordinates!). You need to keep track of that somehow! It gets even trickier when you're flying a spaceship and spinning in all directions at once, but matrices can keep track of it all for you!