For a big chunk of my career I’ve hired and managed database developers. One thing I’ve noticed over the last fifteen years is that database developers are hard to find.  For every ten programmers you talk to, maybe one has any significant experience with databases.

This doesn’t make any sense. Our digital infrastructure rests upon a foundation of databases. Surely database theory and database development are a big part of any formally trained computer programmer’s education. If so, then why are so many programmers disappointingly inexperienced with database development?

I looked at my local Computer Science departments to see what kind of database course work they require of their students. Within a reasonable drive from my office are several colleges that offer a BS degree in computer science, including Bennet College, Elon University, High Point University, the University of North Carolina at Greensboro, and Wake Forest University.

I was disappointed to find that none of these schools have a database requirement as part of their Computer Science BS degree program.

Where are the database courses? Interestingly, UNCG has an optional bioinformatics concentration in their computer science major and this concentration requires a Principles of Database Systems course. And if you get an MS in computer science at UNCG they require an advanced databases systems course or its equivalent. There is no such requirement for the MS in computer science at Wake Forest University, however. Additionally, Bennet College and Elon University both have a Computer Information Systems (CIS or CIT) alternative to the traditional CS degree and each has a database requirement.

The lesson here, I guess, is to stop looking at undergraduate CS degrees and focus instead on people who have studied bioinformatics or CIS, or who have a graduate degree from a school like UNCG that requires database course work. This sucks, since it’s the background in algorithms, data structures, design patterns, and matrix math that make a good database developer valuable, and these topics are at the core of a traditional undergraduate CS degree.

So in the end I can hire someone with a strong foundation in computer science or someone with exposure to databases. That’s the wrong Boolean operator.

It’s been a while since I’ve had to worry about coding emails. But recently a coworker asked me to put together a brief presentation on best practices for email development. This is actually two separate topics, email content and email code. Setting aside email content for the moment, here are my completely derivative, unoriginal, you-can-find-this-anywhere advice for avoiding trouble in the inbox when you’re coding email. This advice assumes you’re building an email campaign for deployment to a wide audience and you have no control over the email client application your recipients will use.

Generally, when coding email it’s best to pretend it’s fifteen years ago. Seriously. I know Dreamweaver can do lots of cool things and I know CSS is awesome and HTML5 is just, like, unbelievable. Nonetheless, ignore it all. Back away from the shiny modern tech.

1. Learn to write HTML
Apps like Dreamweaver make it easy to build web pages without ever having to dig into the underlying code. Unfortunately, these apps make assumptions about the best way to code stuff that runs counter to what you’d want to do for HTML email development. The best way around this is to code your own HTML. There are plenty of great places to learn how to do this. My favorite is W3Schools.com. If you can use Dreamweaver or Photoshop, then you have more than enough technical ability to learn HTML. Just take an hour, one hour, and play around with it. You’ll be surprised how quickly you pick it up.

2. Use tables
Tables are the old way to build compositional structures in HTML. They’re pretty basic, they have rows and columns and that’s about it. The great thing about tables is that most email clients understand them.

Here’s a simple example. Assume you want to build an email with this composition.

These are only the most basic best practices. There are many more things you can do to ensure your email gets where you want it to go and looks like you want it to look when it gets there. But if you follow these seven practices, you’ll be building from a great foundation.

Transposing a matrix is the process of transforming it so that its columns become rows and its rows become columns.  A transposed matrix is usually notated with ‘ or  ^T. So B transposed would be B’ or B^T. Here is our example matrix B transposed to B^T. Note that B has four columns and three rows, while B^T has three columns and four rows.   

You can think of B^T visually as the result of rotating B 90 degrees counter clockwise.

Multiplying two matrices is less straightforward than adding or subtracting. As we saw in part 2, you can add two matrices if they each have the same number of rows and columns. However, you can multiply two matrices only if the number of columns in matrix A is equal to the number of rows in matrix B.

Using our example matrices A and B, A has 4 columns and B has three rows. Since 4≠3 we cannot multiply these two matrices.

However, our transposed matrix from above, B^T, has four rows. So we can multiply A and B^T since A has four columns and B^T has four rows.

The product of two matrices will have the number of rows in the first matrix and the number of columns in the second matrix. So C, the matrix that results from A x B^T, will have the number of rows in A and the number of columns in B^T. C will be a 3 by 3 matrix. This is sometimes notated as C_3×3 or C_3,3. 

The trick to multiplying two matrices is to take each number in each row in the first matrix and multiply it by each corresponding number in each column in the second matrix.  For each row/column combination, add the products together. For example, multiplying A x B^T from above looks like this.

Take the first row in A, 1 2 3 5, and the first column in B^T, 2 3 5 7, multiply them together and add the products, like this.

(1 x 2) + (2 x 3) + (3 x 5) + (5 x 7) = 2 + 6 + 15 + 35 = 58

Stick with the first row in A, 1 2 3 5, and now take the second column in B^T, 11 13 17 19, multiply them together and add the products, like this.

(1 x 11) + (2 x 13) + (3 x 17) + (5 x 19) = 11 + 26 + 51 + 95 = 183

Again, stick with the first row in A, 1 2 3 5, and now take the third column in B^T, 23 29 31 37, multiply them together and add the products, like this.

(1 x 23) + (2 x 29) + (3 x 31) + (5 x 37) = 23 + 58 + 93 + 185 = 359

Good. Now we’re finished with the first row in A, and we have the first row in our product matrix, C.

To calculate the second row in C, take the second row in A, 8 13 21 34, and the first column in B^T, 2 3 5 7, multiply them together and add the products, like this.

(8 x 2) + (13 x 3) + (21 x 5) + (34 x 7) = 16 + 39 + 105 + 238 = 398

Stick with the second row in A, 8 13 21 34, and now take the second column in B^T, 11 13 17 19, multiply them together and add the products, like this.

(8 x 11) + (13 x 13) + (21 x 17) + (34 x 19) = 88 + 169 + 357 + 646 = 1260

Again, stick with the second row in A, 8 13 21 34, and now take the third column in B^T, 23 29 31 37, multiply them together and add the products, like this.

(8 x 23) + (13 x 29) + (21 x 31) + (34 x 37) = 184 + 377 + 651 + 1258 = 2470

Good again. Now we’re finished with the second row in A, and we have the second row in our product matrix, C.

To calculate the third row in C, take the third row in A, 55 89 144 233, and the first column in B^T, 2 3 5 7, multiply them together and add the products, like this.

(55 x 2) + (89 x 3) + (144 x 5) + (233 x 7) = 110 + 267 + 720 + 1631 = 2728

Stick with the third row in A, 8 13 21 34, and now take the second column in B^T, 11 13 17 19, multiply them together and add the products, like this.

(55 x 11) + (89 x 13) + (144 x 17) + (233 x 19) = 605 + 1157 + 2448 + 4427 = 8637

Again, stick with the third row in A, 8 13 21 34, and now take the third column in B^T, 23 29 31 37, multiply them together and add the products, like this.

(55 x 23) + (89 x 29) + (144 x 31) + (233 x 37) = 1265 + 2581 + 4464 + 8621 = 16931

Great. Now we’re finished with the third row in A, and we have the final row in our product matrix, C.

In the code for the calculations above we will build four arrays, A, B, BT and C, corresponding to the example matrices A, B, B^T, and C.

Let’s begin by building A and B and populating the values.

    Sub Main()
        Dim A(2, 3) As Integer
        A(0, 0) = 1
        A(0, 1) = 2
        A(0, 2) = 3
        A(0, 3) = 5
        A(1, 0) = 8
        A(1, 1) = 13
        A(1, 2) = 21
        A(1, 3) = 34
        A(2, 0) = 55
        A(2, 1) = 89
        A(2, 2) = 144
        A(2, 3) = 233 

       Dim B(2, 3) As Integer
        B(0, 0) = 2
        B(0, 1) = 3
        B(0, 2) = 5
        B(0, 3) = 7
        B(1, 0) = 11
        B(1, 1) = 13
        B(1, 2) = 17
        B(1, 3) = 19
        B(2, 0) = 23
        B(2, 1) = 29
        B(2, 2) = 31
        B(2, 3) = 37 

B has four columns and three rows. Since B^T is the transpose of B, it has three columns and four rows.  

        Dim BT(3, 2) As Integer

We populate the values for B^T with nested FOR NEXT loops. The outer loop, x, corresponds to the rows in each array and the inner loop, y, corresponds to the columns in each array.  Populate the rows in BT with the columns from B and the columns in BT with the rows from B.  

        For x = 0 To 3
            For y = 0 To 2
                BT(x, y) = B(y, x)
            Next
        Next 

C is the product of A and B^T. It has three columns and three rows.

        Dim C(2, 2) As Integer

We populate the values for C with nested FOR NEXT loops. Loops x and y correspond to the rows in A and the columns in B^T, respectively, and loop z corresponds to the columns in A and the rows in B^T.  As mentioned above, the trick to multiplying two matrices is to take each number in each row in the first matrix and multiply it by each corresponding number in each column in the second matrix. The loops look like this.

        For x = 0 To 2
            For y = 0 To 2
                For z = 0 To 3
                    C(x, y) = C(x, y) + A(x, z) * BT(z, y)
                Next
            Next
        Next 

Now write the matrices A, B, B^T and C to the screen.

        For x = 0 To 2
            For y = 0 To 3
                Console.Write(A(x, y))
                Console.Write(Space(1))
            Next
            Console.WriteLine()
        Next
        Console.WriteLine() 

        For x = 0 To 2
            For y = 0 To 3
                Console.Write(B(x, y))
                Console.Write(Space(1))
            Next
            Console.WriteLine()
        Next
        Console.WriteLine() 

        For x = 0 To 3
            For y = 0 To 2
                Console.Write(BT(x, y))
                Console.Write(Space(1))
            Next
            Console.WriteLine()
        Next
        Console.WriteLine()

        For x = 0 To 2
            For y = 0 To 2
                Console.Write(C(x, y))
                Console.Write(Space(1))
            Next
            Console.WriteLine()
        Next
        Console.WriteLine()
    End Sub 

End Module

And here is our output.

You can add or subtract two matrices if they each have the same number of rows and columns.   Let’s take our example matrix from the previous post , A , and add it to a second matrix, B .

Adding these two matrices is as simple as adding each element in A to its corresponding element in B .   For example, the first row first column value in A is 1. The first row first column value in B is 2. So the first row first column value in A+B is 1+2 or 3. Calculating the whole thing looks like this.

Matrix subtraction works the same way, only you subtract each element in A from its corresponding element in B . Subtracting A from B looks like this.

As I mentioned in the last post , you can represent a matrix in VB.NET with a multidimensional array. In the code for the example calculations above we will build four arrays, A,   B, C and D. Arrays A and B correspond to matrices A and B . Array C will contain the sum of matrices A and B , and D will contain the difference between A and B .

Let’s begin by building A and B and populating the values.

    Sub Main()
        Dim A(2, 3) As Integer
        A(0, 0) = 1
        A(0, 1) = 2
        A(0, 2) = 3
        A(0, 3) = 5
        A(1, 0) = 8
        A(1, 1) = 13
        A(1, 2) = 21
        A(1, 3) = 34
        A(2, 0) = 55
        A(2, 1) = 89
        A(2, 2) = 144
        A(2, 3) = 233

        Dim B(2, 3) As Integer
        B(0, 0) = 2
        B(0, 1) = 3
        B(0, 2) = 5
        B(0, 3) = 7
        B(1, 0) = 11
        B(1, 1) = 13
        B(1, 2) = 17
        B(1, 3) = 19
        B(2, 0) = 23
        B(2, 1) = 29
        B(2, 2) = 31
        B(2, 3) = 37

Next, build C and D.

        Dim C(2, 3) As Integer
        Dim D(2, 3) As Integer

We populate the values for C and D with nested FOR NEXT loops. The outer loop, x, corresponds to the rows in each array and the inner loop, y, corresponds to the columns in each array.   Populate C by adding the corresponding elements x,y from A and B. Populate D by subtracting the corresponding elements x,y from A and B.

        Dim x, y As Integer
        For x = 0 To 2
           For y = 0 To 3
               C(x, y) = A(x, y) + B(x, y)
               D(x, y) = A(x, y) - B(x, y)
           Next
        Next

Now run the nested loops again to for each array and write them to the screen.

         For x = 0 To 2
             For y = 0 To 3
                 Console.Write(A(x, y))
                 Console.Write(Space(1))
             Next
             Console.WriteLine ()
         Next
         Console.WriteLine()
 

        For x = 0 To 2
             For y = 0 To 3
                  Console.Write(B(x, y))
                 Console.Write(Space(1))
             Next
             Console.WriteLine()
         Next
     Console.WriteLine()

         For x = 0 To 2
             For y = 0 To 3
                 Console.Write(C(x, y))
                 Console.Write(Space(1))
             Next
             Console.WriteLine()
         Next
         Console.WriteLine()

         For x = 0 To 2
             For y = 0 To 3
                 Console.Write(D(x, y))
                 Console.Write(Space(1))
             Next
             Console.WriteLine()
         Next
         Console.WriteLine()

     End Sub

And here is our output.

Next time we'll look at matrix multiplication. 

In math a matrix is simply a table of values, generally drawn like this.  

Note a couple things here. The variable the matrix is assigned to is usually bold, and the table of values is usually between a set of brackets. The example matrix above is a 3 by 4 matrix, with three rows and four columns. 

In VB.NET you can represent a matrix with a multidimensional array. The only real trick is to remember that you start counting rows and columns with 1 in a matrix, and you start counting rows and columns with zero in an array. So a 3 by 4 matrix is a 2 by 3 array. It will have the same number of values in it. The matrix has 1,2,3 rows and 1,2,3,4 columns; the array has 0,1,2 rows and 0,1,2,3 columns. Here is the code for the above example matrix.

    Sub Main()
        Dim A(2, 3) As Integer
        A(0, 0) = 1
        A(0, 1) = 2
        A(0, 2) = 3
        A(0, 3) = 5
        A(1, 0) = 8
        A(1, 1) = 13
        A(1, 2) = 21
        A(1, 3) = 34
        A(2, 0) = 55
        A(2, 1) = 89
        A(2, 2) = 144
        A(2, 3) = 233

Now that we have the array built, let’s print it out and compare it with our matrix.

        Dim x, y As Integer
        For x = 0 To 2
            For y = 0 To 3
                Console.Write(A(x, y))
                Console.Write(Space(1))
            Next
            Console.WriteLine()
        Next
    End Sub

And here is our output.

The array has the same values in the same row, column locations as the example matrix.

Next time we will build a second matrix and look at how we add and subtract them with arrays.