JV B/C Podcast E3: Learning

In this episode, Jeremy talks about how we learn, how we teach, and processing information.  Let’s tour through the Business Central Sales and Purchase Document Flow.  Finally, for the new to BC Devs. – Table, Records, and Practices.



Pre-Intro Talk

Good morning everyone, or whatever time it is where you are watching. I seem to be developing a habit pattern of doing this exactly at 9 am on a Sunday morning, but enjoy this whenever it is your time. Today, we are going to be talking a little bit about learning, strategies, and thinking about how we learn. And then, for our functional area, we will be talking about the document flow of how core functionality and Business Central works, because I have seen a lot of people in power platform be a little confused as to how BC does things, which is a little bit different. And then lastly, we are going to be talking about in depth for developers a little bit more about what is a table versus what is a record, and some of the different pieces to that. So enjoy, and let us dive in.

Intro Music

Talking about Learning and Processing

Good morning, everyone. Let us talk a little bit about learning. I have done a couple of conference talks in the past year, and in both of them I mentioned or spoke about the idea of learning. As you know, we have had some conversations with our child, who is a teenager, about some of the different challenges that you can find in how we learn. A lot of times people have the learning habits that they picked up in school, whether it be through the big foundational Elementary and Secondary School, or, if they continued on to university, they have some of the study habits that they acquired along those lines. But a lot of times, if you have not really sat down and thought about it, you have not put a lot of thought into “how you learn”.

I kind of wanted to talk a little bit about that, because I have done a lot of training sessions for people at various levels of skill and background knowledge on how to use Business Central. A lot of those times there are also, classes on how business problems are solved. One of the things that people forget is that when you are sitting in a room, and you are figuring out how we are going to do inventory cycle counts, you have to know a fair bit about inventory process to be able to give good advice which makes sense for that customer.

The thing about that is that there are so many different things to always know. It is a real challenge. We talked in one of our earlier episodes about what you do not  know you do not  know!

So, let us talk today about how filling-in those gaps works. The topic that came to mind is I had the pleasure of taking something called the Great ADHD reset earlier this year. It is an online group, ADHD coaching class. While it did not introduce a lot of new information for me, since I have gotten pretty far along in my voyage of understanding how I think and how I work, there were a lot of great structural pieces. One of the things that we talked about, and which had a lot of good value, was processing styles; there is some value to thinking about how you process information in different contexts. For example, oftentimes when we are training people on how to use Business Central, we set up a classroom. We might have set up a team’s meeting in the past couple of years. But some mechanism of learning is when someone sits in a room and watch you explain how something works and, if you are pretty enthusiastic teacher, you might even put together some exercises, some practice ways for them to do the process that you have just taught them.

This is discussed in the MCT training. I have been a Microsoft certified trainer. There was a period of several years where there were not any Business Central / N.A.V. certifications, so I let it lapse. But because you had to teach the official official courseware, and the official courseware went away.

But what they teach you in that is to acknowledge that people are different types of learners, as well. They also, addressed a few of the processing styles that I have come to learn this year. For example, some people are very visual learners, they see what is on the screen, they can process that information, they can internalize that and make that part of their skill set. While some people listen to how things work, they need it talked through to understand the process, and this process of listening is very important to them.

Some people are very much the Sort of folks who need to be hands on and actually do the work and do the process. And so, when they train you to doing the training through the “Train the Trainer Program” for the MCT, they teach you to build your curriculum and build your courses to speak to a variety of those different learning styles.

That is pretty good. I think my favorite point made during my “Train the Trainer” session was when you are developing your curriculum, one of the most successful strategies for sharing information with people to get them to learn new things is the Sesame Street approach. For those of you in the US, you might know it, or at least it was the Sesame Street, I cannot speak to it in the past 15-20 years. But, effectively, outline what you are going to learn in the upcoming session, repetition through those core concepts, and then a recap of what you did learn. That mechanism is a great structure for helping people understand, on a module-by-module basis, what you are supposed to know; here is what you were going to learn and here are those pieces presented. You also, want to keep it to three to five topics within those spaces. If it is more than that, it will too big of a table of contents for people to hold in their head. And then, at the end of that process, a re-cap of what you should have learned.

If you follow that structure when you are teaching, or more importantly, when you are trying to teach yourself, i.e. learn, it more naturally reinforces what you are trying to pick up. If you are creating those courses for others, that also, gives a really good break point, because brakes are important and valuable for letting things process and sink in. Remember that the idea of teaching and learning is that you are taking external knowledge, external wisdom, and you are internalizing them. That is why I liked the idea of talking of processing styles, and the processing styles that I was taught in the coaching classes here include the visual and the auditory, and I appreciate them.

But they added some other fun ones that I thought were pretty fantastic. For example, some people are verbal, in that they need to talk out. The process of thinking through things that are important is something that they need to talk through. You will see this sometimes when you are teaching other people and some would have questions. The question might be short, but they are explaining a lot of stuff to lead up to that question. That person is possibly a verbal learner, and they are actually processing through what you have just taught them to be able to articulate the part that they did not understand, that was a really interesting one.

Another processing style that I was not familiar with was kinesthetic. It means that some people might need to move, to be physically engaged with their space in some manner or another to be able to focus and understand. You will see this in people who are fidgety, like me. You will see this in people who need to always be fiddling with things, this often comes out in the form of some of the people who will take lots of notes, they might not realize that the process of the moving and taking the notes is helping them focus on the listening and processing the information. Notes as to parts, or maybe even three. Thus, it is more than that, but I thought that was sort of interesting.

And again, breaks and exercises are valuable to adding that kinesthetic experience to the workflow. So, if you are the sort of person who is kinesthetic then know that cannot fidget toys. There is this beautiful community of spectrum people. And there are all sorts of little things that you can just have in your hands to fiddle with and play with. I almost always on the stream, and fiddling with something in my hands. It is why my hands are not on screen. And I do not type during this part of the sequence, because I will tap a lot. I also, thought it was interesting that there is a tactile, which I interpret in the world of learning software, that those are the people who are much more about the I need to learn by doing that the process of doing something with my hands, and interacting with what I am trying to learn is the key thing to me.

That made sense. I could see tactile being also, to process. But the other three were sort of fascinating to me, that I had not really thought about as conceptual, intuitive, and emotional. And that was not anything I had put to a thought before, that some people need to understand the broader context, you need to understand the whole concept. For example, before you tell me to go to this screen to click this button, I need to understand what is the end goal 20 fields from now, 20 clicks from now. I need to have that roadmap ahead of me to be able to feel comfortable to process this. And this is where, for example, many educators will come from the Syllabus School of thinking of that you need to have that educational outline, what things we are going to be learning? Particularly people who are spectrum. We need to have some sort of context for… for instance, you are teaching me something, but I do not know why. Or, I will learn a lot better over the next hour and a half if I understand what, in broad strokes, we are going to be learning today. So, I can prepare to receive that and process this in the right way.

On the flip side of that, there is also, intuitive, some people work really well, by being given a little bit of time to kind of free rein and have their own thinking and processing moments. These are the type of learners that you can give directions to, they are like a visitor driving somewhere; they will learn it better through the process of getting lost and figuring out their way to the place that they were trying to get to. And I think that is kind of interesting.

Emotional does not come up as much in business, ERP software training, but I have seen where emotional learners can have a negative impact. For example, there are times where I was teaching warehousing people or financial processing people how to use pieces of software, and what they were clearly thinking is; “Oh, gosh, this is so much more work, and I am already drowning”.so they were building and building some negative emotions that were inhibiting their ability to learn.

Thinking about this as a processing style. This meant that people coming to the classroom might have an emotional connection to what they are going to be learning today. And if you can work to acknowledge those people and to relate to them a little bit better, you acknowledge that they are worried about these things, and maybe you can give them some resources that speak to those worries. And as you peel away those layers of worry, there is more room for them to learn.

Thus, someone who is really worried about like; “We have gone to this screen, we had to release it here, we then had to go create this process here. Now we can go to this screen over here, and we can print the thing I need to give to the forklift driver”. As you are demonstrating and teaching these things, they are going to be thinking; “Oh, God, that is a lot of steps”. Well, you can address some of that worry by saying: “I am going through this step by step slowly, in order to be able see how this all works. After we go through the process, I will show you how quick it can be if you need to do this quickly, because the truck is going to leave in 10 minutes”. That sort of acknowledgment will relieve the stress of learning what is in front of them. And I thought what was a really good add to the landscape of thinking about processing styles was that emotional connection with what people are worried about in the classroom is also, a big deal.

So, how do you connect all these different pieces for yourself? Well, that is an interesting challenge. The framework that I worked through in our group-learning, which I thought was really fascinating, is that all of those different processing styles vary based on the context, sitting in a classroom, learning from someone how you do a process, is different from when you get back to your desk from a vacation two weeks later, how do you remember that? How do you remind yourself of that information? Or, six months down the road? How do you potentially stay focused and engaged with that learning?

So, it is important to kind of think through some of those different things. And by just building that map, you might give yourself a little more freedom and understanding of “How can I process this information a little bit better?” For example, one of the things that you might be much more of a kinesthetic sort of person, you are very active person, and the idea of sitting still in a classroom and listening to someone explain something for two hours, is just not what you are going to be able to do, or it is very challenging for you to process.

Ask the question of “Is there any ability I can record the audio of this classroom?” Record that, download it on your phone, and take a walk and listen to it while you are walking around. That might engage you better, you might start thinking that “Now I can connect with this a little bit better”. Thus, think about some of those different pieces and try to give yourself the structure that a classroom would give you if you are learning by yourself. Have some loose objectives to, for example; “I need to learn how to code BC”.

Well, if you are trying to say “I need to be able, as a solution consultant to add a field to a customer card, because that seems like something I should be able to do as a developer”. Yes, but that is a big outline. So, work with someone who does know how to do that, and break that down into the smaller modules so that you can potentially say; “I can set aside an hour, an hour and a half, to learn these two pieces of that”.

I had a solution center, I worked out where I ended up temporarily, for about a year or so being a manager of an IT consultancy department, in addition to doing development work. Busy times. When you are a small company, you do all the things you can do. But the folks that we had the opportunity to acquire that were a good fit culturally, that made sense for the company at the time, had a lot of stuff that they needed to learn about what we did as a consultancy, or as working with Microsoft products. What was extremely helpful for them, and you probably should do this for yourself, is sit down and build a high level – does not need to be in detail – just high level visual roadmap that you can say. “Okay, I need to learn these 20 to 30 topics. I do not need to be a master of them”. Maybe you do need to master them.

But take all of those topics, build yourself some sort of visual representation of the sequence of all the different things you need to learn. Print it out, and stick it on the wall. Put it somewhere where it is outside of your head, and then as you are working your way through it, and as you acquire those different skills, check them off visually, give yourself the cue of “I am making small progress on this big plan”.

If you are not sure what sort of learning objectives you should have, there are wonderful people in the industry. LinkedIn has great groups. Twitter has great communities around, people chatting about things, the discord servers out there. If you are not sure what your roadmap should look like, reach out. There are lots of places for you to get some help building a roadmap for yourself. So, I do not know if that was helpful. But hopefully that gets you thinking about questions like; how do you teach yourself? How do you work with others learning things?

Document Flow in BC

Today, I wanted to dive into one of those, because I take this for granted pretty easily. It is something that I had to explain to someone recently, and it was not connecting for them immediately. And I had to really think about why did not it connect with them immediately. We had talked about how the table object is a set of fields. Let us take, for example, in our base app, if we pop open something relatively simple – payment terms – if we go to the table definition of payment terms, we have in the Payment Terms table we have field 1 is code we have field 2 is due date calculation, field 3 is discount date calculation, field 4 discount percent, field 5 is description. We have also got a few other little auditing and assisting fields.

 There is only a handful of fields on this particular table. If I wanted to work with the Payment Terms table in code, it is fairly easy to understand that I can assign things to these to these different fields. Now, let us make a new code unit really quickly, interest in a root of our folder, let us grab a code unit. And we will name it tinkering with tables.

I have got a code unit, where I am going to say I would like to have a function that auto generates a set of payment terms in that table for me. As such, I am going to create, and I will just keep this simple. And we are going to use this as the on run trigger. Thus, if someone runs this code unit, it does the following steps. We are going to do a couple of pieces of hard coding, which if you are new to development means that we are putting right in the code the values that are going to be created, and in production environments. You should not do sort of thing. You should not hard code things. For the most part.

There are good circumstances, but we will talk about that in a whole separate episode. If I want to work with a separate table like payment terms, I need to define a variable using little bar logic here for the Payment Terms table. And what is interesting is that first of all, if you had not worked with AL so far, you have to strongly type all of your variables. If you are coming from other programming languages, everything is strongly typed, we have to define exactly what this variable is pointing to.

I am creating a new variable. Here is my type, which is that is how the format goes. We have named colon, and then we have typed, and then we potentially have any extra information that comes after type. For example, I am saying I want to work with a table object. And you will notice that to work with a table object I am not typing payment terms is a type of table. That does not  work. There is there is no variable data type called table, which is delightfully confusing for folks who are new to this. Let us grab payment terms.

We can see here I am defining a variable that points to a record called payment terms. And if I mouse over each of these different pieces, you can see that payment terms gets a tooltip that then lists all of the fields that are on that table. And I know I am looking at the right thing. Here is the code, here is the description, there are those date calculations, and all that sort of stuff, and all of our miscellaneous extra things. There are some fields in this list that are automatic that you may not have seen. But that is another topic. If we hang out and mouse over a record, we do not  get any information. If we mouse over payment terms, the tooltip says it is coming from the table payment terms. So, why are there two different names for the same thing?

The table is an object type, and the record is a variable type. And what I like to think of it is that the table is the definition of how all the data is stored. And it then can be accessed via a record Data Type. And record comes with a whole bunch of extra stuff. What kind of extra stuff? Let us use a variable and take a look at the IntelliSense that pops up when we use payment terms, and we type (.), we get a whole bunch of stuff in our tooltip drop down here for the IntelliSense. We get these four things right up top here, “Get description in current language”, “Get due date calculation”, “Translate description”, what are those? they get this weird little purpley icon. If you have not seen it before, in Visual Studio code, that means function, roughly. And then we get these little blue icons with those fields that we saw, like “Code and description”, the “Date calculations”, and we can scroll on down even further. And we start getting more of those purple icons, which are all sorts of things like “Aadd link”, “Our fields”, “Loaded calc fields”, “Copy filters”, and tons and tons of stuff on this list. This is because the table defines a few different pieces, the table defines the fields.

And if we go back to this, I am going to keep it open this time. If we scroll down past the fields, there are also some procedures, i.e. functions, that are callable pieces of code on this table. And those were the things that we saw in the first part of the list. So, in our IntelliSense, these first four are specific procedures that are designed to be available to us anywhere we are using that table object. And then we get all the fields. And then we get a whole bunch of other extra functions, like what is count? Count makes pretty good sense. We can guess at what this does. If we select that from our IntelliSense and mouse over, it tells us that this procedure count counts the number of records in a table.

Now you just hit us with a fun thing. Here, we are working with a record variable that is pointing at a table. And the count function tells us that it is counting the number of records in the table. What happened in the mix and match on the language here for new people? That confuses people. If you are brand new to database development. And even if you are not, necessarily, you get a little lost trying to understand this. 

Let us see if I can doodle up some explanation that helps as we talk through this, I do not know if I can, we will see. Thus, on the table object itself, a table contains all of those fields that data lives in. And as we would expect, within a table, we can have multiple rows or records that the data lives in. For example, I might have two records, individual rows of data. A record inside of a table object is effectively a row of fields, and the fields are like columns. As such, you have this data grid that lives inside of the table.

Additionally, BC tables can have separate little functions that you can call. Tthat way, regardless of which row you are on, you are able to call these functions and those will work with whichever row you are currently active on. And what do I mean by that? If we come back and look in here, we have some functions. Let me close that. If when you look at the Payment Terms table, when we call get description in “In current language” – one of the functions that is on this table – what that does is it attempts to translate based on which code is the current code of the Payment Terms table, it attempts to translate the description if there is a translation. This procedure knows that it has to be called from a particular row of information, i.e., a particular record of information.

So, if we wanted to pop a message of the description, then we could write; “Message, payment terms, get description in current language”, and it considers this valid code. It assumes that your payment term’s record is variable, which is not the same as a record in the table. It assumes that your record variable has a context meaning that we have told it to go to a particular record in the table. If we go look at payment terms for a sec, just to give some visual for those who are new to BC, if we go to the Payment Terms table, for example, a common thing would be like 30 days is a code. The due date calculation is 30 D, which means that anytime we use this payment term on a sales invoice, whatever date is our posting date, the due date will be 30 days later.

And we can see, for example, in the background, this posted sales invoice we were looking at earlier, where we got a due date automatically. And we can see that the description here is net 30 days, if you are sending this invoice to a French customer or German customer, you might want that to be translated. And there is a engine in here that you can say for a given language, I want the description for net 30 days to be changed to this other language. So, what we are looking at here is that theoretically, this is going to translate the description, this function will do this task. The thing about it is that the record variable is not only pointing to the table, but it also points to a bunch of different stuff.so the table has records in it. But a record variable is almost a layer on top of that. And what I mean by that is that it does point to a table.so that way we know what all of our fields-structure is.

So, we get all of the funds in packs of we potentially know what fields there are on this table. And we also know what functions there are on this table. But we also get a bunch of other stuff in the variable as well. The other stuff we get are the built-in functions, that automagically come as part of being a record variable. That includes things like the count function and any number of different procedures. But we also have on top of that filters have been applied to the record variable. And additionally, we aslo have positional information on where we currently are. Thus, there is a lot of extra information that comes with being a record data type.

For example, typically when we work with a record type, the first thing that we would often want to do, if we say our message is we want when we run this code unit to show the translation for the net 30 days Payment term, and the very first thing that we would do is we would filter for the desired data, we then would move to the desired data. Move to the desired data. And then we can operate on that data. Thus, when we are looking at our Payment Terms table, when we first initialize the record variable, it has no information about where we are, and what line we are on. In my UI, I can just click on it. That makes sense. And as far as filtering goes, I could show how we might filter on, for instance, anything that starts with 30*.

Now that I have applied that filter to my code, we can see this gets me my 30 days. Obviously, the code I am doing here is bonkers. But it gives a core concept. Payment terms, what we can use is one of those built-in functions, that is way down in the bottom of our list here, this set filter. This allows us to do what we just did in the UI where we are changing the filter list programmatically. Now we can say just like here in the scene, we can click on add a filter, and we say which field we are filtering on, and then provide a value. In the set filter function call, we can say set filter on code, and I can say 30* as the parameter that I pass through the set filter function. Anytime you are working with these procedures, there is usually some degree of tooltip that will tell you a little bit about things. It does not always make a lot of sense. As such, just be aware that sometimes you are going to run into things that you are going, for instance, why is this talking about set filter takes a parameter or a field called Joker?

We will talk about that. I have now set the payment terms, if I were now to say operate on the data without that motion, which is a common rookie mistake of set all your filters, and then forget to move. If I now do a message on the payment terms, and I do my get translation, get description, current language function. This, without the comments, might look like it would work because we set the filter to 30+, and we are all good, right? Well, no. You have to still have the motion aspect. Hence, thinking about it from this perspective of work. On this table, we have got all of the individual records of data, the rows of data in here, we have now applied the filter layer, but our position in the table has not changed. And so we, as developers, have to do extra work to move once we have set the filters. Even though in the UI, when we set the filter in the UI, it automatically drops us right to the right record.

Well, developers, we might need to set about 10-20 filters right in a row. And within that context, we do not  want it to go back to the database every single time and ask for all the records for 30*. After all, sometimes, these filter sets, if you only applied one filter, you might be talking about thousands of records. As such, it wants you to have the opportunity to do your own work. In my case, one of the ways that we are going to use move, is we can use one of these different find-functions, to be able to use Find first or find last to try to get to a single record. Thus, I will do find first.

If you have not worked with the record types before, there are lots of different things we are going to dive into about this, but I I realized not too long back that this was something that was a real challenge for someone new to BC to work with. Because when we are looking at this, we are saying that we have a table which contains records, a record data type points to a table and within that record data type containing those tables, there are individual records we have to move between record-table-record. That that is a doozy of an understanding gap. Thus, it really helps to just have that Background.

In our next episode, we will go ahead and start on how you potentially work with some of these different records and what we can do with those things. But I hope that that is going to be a more useful understanding of how the language reduced clarity for maybe some folks who are working with this for the first time. All right, we are at the hour mark, I can babble about this for days and days and days. But there are always other things to do, including some different pieces. And I hope that this has been a useful session for you, that it gets you thinking a little bit about the ways that you learn or the ways that you help other people learn. And let me tell you, helping other people learn is a very big thing.

I encourage people who are bringing on new people into their practice to try to bring on two or three new people at the same time. This way they can collaboratively learn together, you learn more by trying to teach the different things. We also talked about the document flow. And hopefully that makes more sense. Now when people are trying to build Power BI and automates against BC, to understand better that this is how it all works. And if you have been a newbie developer who is trying to understand how data lives in the system, how you work with the data in the system, hopefully, now,  some of the language that was maybe confusing around what some of these different steps are, has a little more clarity. As such, with any luck, they will continue to build on all of these different pieces and I hope this has been of help. So, Goodbye, everybody, and we will see you next week. Take care everyone!