 In this edition I'm going to look at the empty arrays and an empty array is any array that has a zero in its shape. So if it has no rows or no columns or no tables, it's an empty array. There's essentially nothing there. If I look at the standard display I can look at some variables and these variables all look the same. They're all empty. They just return the next line. That's not true of every empty array. You can have variables that will return three lines and although those last two both return three lines we're going to see that they're quite different. So let's look at the enhanced display and see those differences. So starting with A I see it's shape zero and it's an integer. Now I could as well create a shape of a literal and that means I would start with the literals but there's no literals. It's zero shape. It's got nothing in it but it started from literals. So I've included that information because sometimes it can be useful. Sometimes it makes no difference at all but I thought if I know it I might as well put it in. It looks at B. So B is interesting because it has a different shape, zero zero instead of zero and yet it looks the same. And that was something I had to kind of wrestle with because I wanted them to look different but the only way for me to make B look different than A was to ripple a whole bunch of complexity through the rest of the displays and to me it made more sense just to say if you hover over it you'll immediately see that it's a different shape than what this one is. So a different shape between those two but it's enough that you know that it's empty because it's signaled that way. So let's look at C. So C is different again. It is two zero three is the shape. So the zero is the rows. It's got two tables, zero rows and three columns and it started from integers. But A, B and C all displayed exactly the same within the standard way of looking at J. Let's look at D and E because they're different again. So I've got D and I have E. And you'll see here if I look at D here it's shape is two one zero and E it's shape is three zero so they're not even the same rank. So there's significant differences going on there. And it was my feeling that if things are different I want them as much as possible to look different and that's why I've designed it this way. Now I'll go back to the standard display and we can look at some of the things that show up when you're boxing zero shaped arrays. So here's an array I've developed. That's what it looks like but given the size of the boxes it actually becomes confusing as to what's going on inside. You can know they're empty. There's nothing in them but you don't know the shape of what's in them. At least it'll become apparent when we see this in the enhanced display. When we see suddenly there's an awful lot going on inside there that's not shown in terms of the regular display. So if we look at this we see this is two zero. This is zero three and it happens to mean from a floating if that made a difference. This is three zero two and it's a rational if that made a difference. And then this is zero three two and it's extended if that made a difference. So all that information is included in the way that I've chosen to show empty arrays. And although there is a disadvantage to this is sometimes if you want to have a return that looks like it's nothing you would do something like this and just return an empty line I'll actually return something that tells me what shape it is. And so that is a disadvantage. If I go to the standard display and do the same thing it just goes to the next line. So that's a convenient way to have just the next line return and you'll see it happen a lot in J. My visual way doesn't do that but I'm not thinking of my visual way of doing things so much as a way to create programs that display for you. I'm actually more interested in seeing what the program is doing while I'm creating it. So I think they're two different tools but I find my tool a lot easier to work with when I'm programming.