Oct. 29, 2024

Episode 345: In the Dynamics Corner Chair: Code Craft: Mastering Reviews, Clean Code, and AI

Why should everyone in a team participate in code reviews? Because it's more efficient than doing it ALone! 😄

🚀Join us in this episode with Natalie and Stefan as we explore the ins and outs of code reviews, the art of clean code, and the transformative power of automation and AI tools like Copilot. 🧩

Key Takeaways:
🌟How to leverage code reviews to maximize collaboration and learning.
🌟Why you should strive for the holy grail of clean code, even if it's out of reach.
🌟How automation can tidy up your code, but why manual reviews remain crucial.
🌟Why it's important that everyone participates in code reviews, regardless of experience.
🌟Yes, documentation remains a challenge, but what can we do about it?
🌟Programming languages are evolving fast. Are you keeping up?
🌟How community resources like #Discord can be a source of support and learning.
🌟Last, but not least, why it's critical to engage with the developer community to maintain best practices.

🎧💡Are you ready to develop your development journey?

Send us a text

#MSDyn365BC #BusinessCentral #BC #DynamicsCorner

Follow Kris and Brad for more content:
https://matalino.io/bio
https://bprendergast.bio.link/

00:02 - Clean Code and Automation

11:01 - Software Development and AI Integration

22:55 - Leveraging AI in Software Development

34:57 - Code Review Best Practices and Updates

49:10 - Language Evolution and Technology Utilization

WEBVTT

00:00:02.185 --> 00:00:09.009
Welcome everyone to another episode of Dynamics Corner, the podcast where we dive deep into all things Microsoft Dynamics.

00:00:09.009 --> 00:00:18.887
Whether you're a seasoned expert or just starting your journey into the world of Dynamics 365, this is your place to gain insights, learn new tricks and fact-checking.

00:00:18.887 --> 00:00:20.792
Co-pilot in AL for review.

00:00:20.792 --> 00:00:22.385
I'm your co-host, Chris.

00:00:23.080 --> 00:00:23.742
This is Brad.

00:00:23.742 --> 00:00:27.533
This episode was recorded on October 2nd 2024.

00:00:27.533 --> 00:00:31.187
Chris, chris, chris, welcome to October.

00:00:31.187 --> 00:00:33.347
Welcome to another great episode.

00:00:33.347 --> 00:00:40.273
This episode is a follow-up to a conversation we had with two well-known Business Central community members.

00:00:40.273 --> 00:00:53.331
Back in August, we had the opportunity to start talking with them about code reviews and clean code, and today we had the opportunity to talk with them a little bit more about that topic and also how they utilize Copilot within their daily workflow With us.

00:00:53.331 --> 00:00:55.726
Today we had the opportunity to speak with Natalie Carioca.

00:00:55.726 --> 00:00:57.973
Carioca Niddy, I call her.

00:00:57.973 --> 00:01:01.847
I'm bad with the bad last names Natalie Carioca and Stefan Moran.

00:01:01.847 --> 00:01:13.125
Good afternoon.

00:01:13.144 --> 00:01:13.906
How are you doing?

00:01:13.927 --> 00:01:15.790
Morning, oh morning, good morning.

00:01:15.850 --> 00:01:20.766
Good night I don't know.

00:01:20.766 --> 00:01:21.748
Really.

00:01:21.748 --> 00:01:24.572
No, it's still early, very early, but it's all good.

00:01:27.159 --> 00:01:27.441
No, it's okay.

00:01:27.441 --> 00:01:28.668
See, we need to do that with the backgrounds.

00:01:28.668 --> 00:01:31.341
We should just have a consistent background, so that way you can't tell the time of day.

00:01:31.341 --> 00:01:35.170
Yeah, so that way it could be, we could pretend it's one.

00:01:35.691 --> 00:01:48.986
I'll close my blinds I could have like what stefan has just you know, white background I like that though you could do a lot with a white background.

00:01:49.560 --> 00:01:53.665
Yeah, I intentionally turned my desk so for the streams I do.

00:01:53.665 --> 00:01:55.490
I have a neutral background.

00:01:55.490 --> 00:02:02.605
Normally I have my camera also cut off, so the mess on my desk is not visible.

00:02:02.605 --> 00:02:04.971
Let me know.

00:02:04.971 --> 00:02:08.049
I'm not sure how the podcast will turn out.

00:02:08.049 --> 00:02:10.990
Otherwise I will just quickly remove some of those things.

00:02:13.381 --> 00:02:14.727
No, the neutral background is good.

00:02:14.727 --> 00:02:17.407
I was thinking of putting a green screen.

00:02:17.407 --> 00:02:18.651
I have a green screen.

00:02:18.651 --> 00:02:22.830
I was thinking of putting it behind me and just putting something behind me.

00:02:22.830 --> 00:02:42.044
One time I had a meeting I used the green screen and I took a video of a coffee shop that I found online and with OBS it filtered the chroma key for the green screen and worked well, and everyone thought I don't know, chris, if you recall that, everyone thought I was in a coffee shop Because there were people walking.

00:02:42.044 --> 00:02:47.862
I mean, it was a loop so it didn't jump, so it looked like I was in a coffee shop, but I was really.

00:02:49.883 --> 00:02:51.647
That's pretty clever man no.

00:02:51.687 --> 00:02:52.310
I have to do that again.

00:02:52.310 --> 00:02:52.751
Well, that was.

00:02:52.751 --> 00:02:56.506
I wanted to put myself in an X-Wing from.

00:02:56.526 --> 00:02:57.669
Star Wars and have space.

00:02:58.262 --> 00:02:59.546
It was back in May 4th.

00:02:59.546 --> 00:03:03.167
I wanted to pretend I was in an X-Wing and have the stars, but I couldn't find the video.

00:03:03.167 --> 00:03:11.044
Jeez, Natalie and Stefan are like what are these guys talking about?

00:03:11.044 --> 00:03:11.866
It's fine, go on.

00:03:11.866 --> 00:03:17.768
I remember when we talked last time.

00:03:19.044 --> 00:03:27.290
Several times I heard you say wow, we could continue talking about that much longer, though I don't remember the details anymore.

00:03:32.721 --> 00:03:33.424
That's even better.

00:03:33.424 --> 00:03:34.828
So we'll pick it up.

00:03:34.828 --> 00:03:39.229
No, thank you both for taking the time to speak with us again.

00:03:39.229 --> 00:03:56.325
It was back in August when we spoke, if you recall, a few short months ago we were talking about code reviews and clean code and during that conversation we did say and even afterwards we talked about how we could talk about this forever or for several more hours.

00:03:56.325 --> 00:04:07.348
Forever is a long time and we wanted to follow up with that in talking about code review and clean code and other uh points.

00:04:07.348 --> 00:04:10.060
So that's uh where we are.

00:04:10.360 --> 00:04:11.522
Do you remember the conversation now?

00:04:13.066 --> 00:04:16.192
no, the conversation is is clear, just not like.

00:04:16.192 --> 00:04:22.476
I had some topics in mind, what I wanted to elaborate further on and those specific points.

00:04:22.476 --> 00:04:34.745
They're gone, so I don't know if I will repeat stuff I said before, because I wanted to go back and listen to the episode, at least in fast forward, so I could just continue, but I did not find the time.

00:04:35.367 --> 00:04:35.978
No, it's okay.

00:04:35.978 --> 00:04:42.427
I listened to the episode so I'll try to, and if we repeat ourselves, it's okay.

00:04:42.427 --> 00:04:52.432
It's the important point of the code review, one thing that I was thinking about talking about which we didn't talk about last time.

00:04:52.432 --> 00:04:57.271
We could talk about the code review, clean code and some of the follow-up points that you wanted to talk about.

00:04:57.271 --> 00:04:58.826
I'm sure they'll come back or even additional points.

00:04:59.439 --> 00:05:24.286
But one thing I was thinking about with the world of automation today and I hate to say AI, because everybody talks about AI, but I also know that there are some tools to do, like AZL tools has like a code cleanup and there's other tools available how much of a code review or code clean code right, it depends on what the definition you're talking about is.

00:05:24.286 --> 00:05:24.867
Clean code is which I'd like to go back and actually define what each of you think clean code?

00:05:24.867 --> 00:05:25.494
Right, it depends on what the definition you're talking about is.

00:05:25.494 --> 00:05:29.908
Clean code is which I'd like to go back and actually define what each of you think clean code means.

00:05:29.908 --> 00:05:33.870
But how much of this do you think could be done automated?

00:05:33.870 --> 00:05:41.129
You know, during the pipelines, we can have tests run against code to ensure that the functionality is sound.

00:05:41.129 --> 00:05:47.526
There's other things that we can do with automation during the pipeline process.

00:05:47.526 --> 00:05:50.992
How much of this do you think could be done in that fashion?

00:05:51.839 --> 00:05:55.446
Do you want to go first or should I?

00:05:55.766 --> 00:06:14.142
Okay, I've done quite a bit amount of code cleaning up operations in the last weeks and days and weeks, so especially the tools that Andre wrote, the extension, the ASE tools library.

00:06:14.163 --> 00:06:28.365
It's pretty good to do some of those tasks to just be quicker, but especially those I would not automate and I do not like to have them run through the entire project automate and I do not like to have them run through the entire project.

00:06:28.386 --> 00:06:35.949
Um, when I do those cleanup tasks for for a project or an app or something, then I like to go through the files individually to also pick up the contents and to read through everything once.

00:06:35.949 --> 00:06:46.029
But I'm always a little bit afraid of those with those tasks like there could just be one back in there and it messes everything up and then I need to revert everything that I did.

00:06:46.029 --> 00:06:52.968
So I need to do really granular commits to prevent that and just the hassle seems to be too much.

00:06:52.968 --> 00:07:20.509
So I use those tools but I run them individually on the current file as I go through, just to do some of those like remove duplicate lines or those commands, remove the redundant app areas those kinds of commands I use and I run them frequently, but I'm not through the entire thing and not just on an automated base, more like a developer tool to be quicker, I feel better about that because I'm sorry, natalie.

00:07:22.982 --> 00:07:47.728
I feel better about that because I do it the same way, because I do like to see the changes as a result, because I have come across with some tools not necessarily that tool I love the AZL dev tools but I like to see the differences afterwards just to make sure that what I had intended to be done, because I do a lot of the you know the parentheses, the case, the remove unused variables, the sorting and such.

00:07:47.728 --> 00:07:53.673
So I prefer to see them individually to make sure that it's sound.

00:07:54.701 --> 00:08:03.511
Well, the sorting actually that I have automated on safe in my settings, so I sort properties and variables automatically on safe.

00:08:03.511 --> 00:08:15.509
That is something I like to do because afterwards you have, like in the git, differences when you compare with git or in general you look at commits and see the differences, then you can better align.

00:08:15.509 --> 00:08:18.339
You do not see them moving afterwards anymore.

00:08:18.339 --> 00:08:21.189
So I make sure to have them always sorted in the same order.

00:08:21.189 --> 00:08:24.449
So that's automated, but just in VS code for me.

00:08:24.819 --> 00:08:29.232
Finally, this is one of the few rules that I have disabled for myself.

00:08:29.232 --> 00:08:39.567
My process is currently similar maybe, as yours now, so while I code directly, I already tried to stick to all the rules and remember everything.

00:08:39.567 --> 00:08:49.019
However, before I release, I run the code cleanup on everything on the whole project, and I really I run the code cleanup on everything on the whole project and I really, really must check the results.

00:08:49.019 --> 00:09:00.211
I could not rely on it doing it all automatically in the background, because not only for some new rules.

00:09:00.211 --> 00:09:06.849
There can always be some bugs, or because the IA language has been extended again and suddenly something doesn't work anymore as it used to be.

00:09:06.849 --> 00:09:22.168
There's no guarantee that the tool that worked yesterday works today, so I really need to check the output each and every time, but it doesn't take that much time, so I don't see a problem in that.

00:09:22.168 --> 00:09:27.292
So the question, rather, is Brad, why would you like to automate this?

00:09:28.039 --> 00:09:29.807
Why would I like to automate it?

00:09:29.807 --> 00:09:48.261
I think anything that you can do to save time or to leave time to do other tasks I would like to take advantage of, take advantage of.

00:09:48.261 --> 00:09:55.284
I don't want to reduce quality of any reviews, but it goes with the same type of notion of if somebody spends a lot of time entering data into a system, they may not have as much time to analyze that data.

00:09:55.284 --> 00:10:01.344
So if you're entering financial information or other types of information anytime you're spent doing one task.

00:10:01.344 --> 00:10:03.005
You're not doing another task.

00:10:03.005 --> 00:10:17.480
So if there's some things we can do to save time through this process without losing the quality, right, the key here is I'm not saying you know save time and you know hope that everything works okay.

00:10:17.480 --> 00:10:29.388
I'm saying save time and have something at least similar or near or even 80% of the way which you can do the last 20% of a review or a cleanup.

00:10:31.374 --> 00:10:42.567
I mean, the majority of time does the truth for us already within seconds, and my manual check afterwards takes, I don't know, a few seconds up to half a minute, maybe.

00:10:42.567 --> 00:10:47.388
That's all, if there are no issues, of course, but this is the exception of the rule.

00:10:47.388 --> 00:10:56.285
So I would not see a reason to automate just that, because it is actually automated, and just a little bit of post-processing after it.

00:10:58.250 --> 00:10:58.471
Okay.

00:10:58.471 --> 00:11:01.269
So if there isn't a gain there, I understand.

00:11:01.269 --> 00:11:05.268
So go back to the we talked about before, about clean code and code reviews.

00:11:05.268 --> 00:11:07.606
What is clean code?

00:11:07.606 --> 00:11:15.908
Again we get these words, I see these terms, I see people write them and say I want you know it's again.

00:11:15.908 --> 00:11:28.434
It's a continuation and we'll maybe repeat some of this or not, but I wanted to dive deeper into code reviews and clean code as a definition.

00:11:29.500 --> 00:11:31.104
Well, first of all, clean code.

00:11:31.104 --> 00:11:40.080
For me, it's an ideal I will never reach, but I'm doing my best to come closer and closer, just in general.

00:11:40.080 --> 00:11:53.395
And when we leave this level, then it's of course about rules, about patterns and all that stuff we all also talked about earlier.

00:11:54.740 --> 00:11:56.163
Stefan, what is your take?

00:11:56.163 --> 00:12:11.124
We'll go back into the clean code area well I I definitely agree with natalie here.

00:12:11.144 --> 00:12:23.455
it's um, yeah, I I would say impossible to reach the ultimate clean code um, but the goal I'm following is to make the code as readable as possible and as um reliable as possible in terms of execution as well.

00:12:23.455 --> 00:12:41.965
So when talking about clean code, I also think about approaches to reduce errors, to make it more resilient against users, because if the developer tests code, it obviously always works because he knows how it was written and how it's intended to work.

00:12:41.965 --> 00:12:56.650
But, yeah, catching errors and stuff that's also, for me, a part of clean coding to really write good code not only clean, but also good code no, it is important I mean clean code that I follow the same suit.

00:12:56.691 --> 00:13:02.134
Clean code to me is more readability as well, and the ability to follow through.

00:13:02.134 --> 00:13:18.471
I know some will have conversations about I know many early on in some other languages where you know how much could I fit on one line of code versus having multiple lines of code and versus what do you save but ask that same person to go back and remember what they were trying to do.

00:13:18.471 --> 00:13:20.948
Sometimes it gets a little bit challenging.

00:13:20.948 --> 00:13:31.067
Or if somebody has to pick up that code afterwards and follow it, they can't, so it's a bit challenging to do so.

00:13:31.067 --> 00:13:37.104
With that, with the code review we talked about, I wanted to talk a little bit deeper.

00:13:37.124 --> 00:13:38.899
We talked about some of the things you had mentioned, Natalie.

00:13:38.899 --> 00:13:48.405
You said it takes a few seconds or a few minutes for you to do some of this code review, and someone even asked me the other day when we were talking about code reviews.

00:13:48.405 --> 00:13:53.071
They asked me should I download and execute this and run this?

00:13:53.071 --> 00:13:56.628
It's outside of the tests.

00:13:56.628 --> 00:14:13.011
Is there a point where you think, from doing a code review, someone should package the code and run it and go through it if they have a question about the logic or how it processes I would say that depends a little bit.

00:14:13.692 --> 00:14:15.000
Um has everything.

00:14:15.000 --> 00:14:19.706
Um, I'm trying to remember.

00:14:19.706 --> 00:14:29.082
If I ever did that, though I feel like a code review is more for me a tool of getting to know what has changed for me personally.

00:14:29.082 --> 00:14:37.371
So I'm aware of what this change is intended to do and also to see if there are any flaws I can just pick up by reading through the code.

00:14:37.371 --> 00:14:42.886
I may download the code in order to have the code cops and the assistance in my editor.

00:14:42.886 --> 00:14:52.373
Um, if it's a little bit more, if it's a really big feature pull request, I might decide to run the code and just to see if it works.

00:14:52.373 --> 00:14:59.301
But it's always also a little bit challenging, depending on on the change itself, to get it set up correctly and just it's.

00:14:59.301 --> 00:15:02.306
It's an overhead to really get there to run and test the code.

00:15:02.306 --> 00:15:07.595
But I mean, I could imagine the situation.

00:15:07.634 --> 00:15:33.275
Yes, Well, code review is the name states is just a review of the code and not of the actual functionality, when, when I get a pull request to check, I rely on the writer of it that he has checked the functionality and I'm taking care of the rest and maybe for some little I don't know typos or other small kinds of errors that happen when you write down something quickly.

00:15:33.275 --> 00:15:40.586
So far I would not have ever tested more than that.

00:15:41.307 --> 00:16:01.844
I do have a question around just how you are utilizing this particular tool, and I just got back from a conference and I believe in the past year or this year alone, everyone talks about AI and Copilot.

00:16:01.844 --> 00:16:18.528
I am curious from the both of you if you've utilized Copilot in any form of your day-to-day development, whether that's reaching the clean code or building a solution.

00:16:18.528 --> 00:16:21.240
Have you utilized Copilot and to what degree?

00:16:21.821 --> 00:16:22.503
I may start.

00:16:22.503 --> 00:16:45.427
So I use it mainly and only as the GitHub copilot directly in VS Code to suggest me mainly text and sometimes even lines of code, because sometimes the suggestions are really good or at least near enough to take them over and then slightly change them again.

00:16:45.427 --> 00:16:52.630
But anyway, the copilot is really great if you have some pattern.

00:16:52.630 --> 00:17:02.121
Sometimes you need to write I don't know thousands of codes that look almost the same, except one number that always increases or something like that.

00:17:02.121 --> 00:17:17.032
So something very mathematical yeah, mathematical, let's say and for that case Copilot is really great because it really detects patterns and then suggests the future lines predicted on that, and this is really great.

00:17:17.032 --> 00:17:22.892
However, I rarely rely on more than that.

00:17:23.420 --> 00:17:35.461
Recently I've played around with the GitHub Copilot chat because I needed some regular expressions that I absolutely don't master at all, but well, copilot does so.

00:17:35.461 --> 00:17:39.824
I asked them to return me the regex strings and this really helps me a lot.

00:17:39.824 --> 00:17:46.709
Wow, but for sure we all could use Copilot much more than this.

00:17:46.709 --> 00:17:49.192
But this really ends here for me.

00:17:49.192 --> 00:18:11.576
Inside our organization we also have AIilot to create the descriptions and all the textual stuff and edit to tasks, user stories and so on to write that for us.

00:18:11.576 --> 00:18:20.750
To be honest, I'm not that much working with it though I should, but I know that my colleagues are and the results look really great.

00:18:20.750 --> 00:18:29.587
So it's just a matter of getting used to it, and I didn't start as much you're gonna be forced to adopt to it.

00:18:29.887 --> 00:18:36.207
Uh, eventually I feel like it's been sort of thrown at us and said, hey, you gotta use this at some point.

00:18:36.969 --> 00:18:51.132
So I just want to go a day where I don't hear the word co-pilot or ai, and just see if I could go a single day without it I guess you could if you went and sat on the beach or went and sat in the woods somewhere and didn't turn on anything at all, but it seems to be all over.

00:18:51.132 --> 00:19:00.013
That is interesting because I've used Copilot with code just similar to what you had mentioned.

00:19:00.013 --> 00:19:10.287
I really haven't used the chat portion of it and asked it questions within Visual Studio Code but with GitHub to suggest.

00:19:10.287 --> 00:19:18.227
I guess you could say I always use the tele, but it's like snippets on steroids in a sense, but you can get a little bit more out of it and I've had some fun playing with it.

00:19:19.701 --> 00:19:21.788
Yeah, you really should look at the chat.

00:19:21.788 --> 00:19:30.327
I've used the Copilot in GitHub for a number of things and I feel like it's a better intelligence.

00:19:30.327 --> 00:19:42.008
As you said snippets and steroids so yeah, when I use it for like, for example, I type out code and use variables that do not exist yet.

00:19:42.008 --> 00:19:50.268
Then I go to the variables section and it automatically suggests me to create those, so I don't need to type them twice.

00:19:50.268 --> 00:19:56.685
I just used before this call, literally, and then I've also on stream.

00:19:56.685 --> 00:20:01.354
I've made a prototype for the JSON wrapper.

00:20:01.354 --> 00:20:04.846
So it's somewhere on YouTube where I've defined a complete wrapper code unit for the JSON wrapper.

00:20:04.846 --> 00:20:09.420
So it's somewhere on YouTube where I've defined a complete wrapper code unit for the JSON functions.

00:20:09.420 --> 00:20:28.730
So there I could, just after I created, I think, the first few of them, I just went and let Copilot create all the functions, like 20 or 30 functions or whatever, because it was, as Natalie described, a pattern which would just continue, and it picked up on the pattern and really helped that.

00:20:30.222 --> 00:20:40.530
And for the chat, I once needed to write a recursive function to do number matching on dictionaries.

00:20:40.660 --> 00:20:46.843
So I had like two dictionaries where I would want to like it was for invoices versus payments, where I have.

00:20:46.843 --> 00:20:57.217
I have an invoice, uh amount and I want to see if my payment amounts, like any combinations of the payment amounts I have, would match up 100 to that invoice amount.

00:20:57.217 --> 00:21:14.065
So I needed to go through the first dictionary and then pick up like all combinations and and try and find the combinations that match and I really used like it took me probably an hour with the Copilot chat to really write out that function and it worked really great.

00:21:14.065 --> 00:21:24.083
So I had adjustments made and then I just described the adjustments I wanted to do or I wanted to have in that algorithm and it picked up on that.

00:21:24.083 --> 00:21:40.627
And sometimes there are issues where the copilot tries to do or use commands that do not exist in the AI language and then you just need to bring it up to attention and say that this doesn't exist or recommend something else, and then it just changes everything and adjusts.

00:21:41.721 --> 00:21:42.444
So, it learned.

00:21:44.401 --> 00:21:46.327
Did you use the chat portion for that?

00:21:46.327 --> 00:21:51.267
Yes, to type out in natural language what you were looking to do, and it created the AL code for you.

00:21:52.701 --> 00:21:58.924
I even created example dictionaries just in text, in pseudocode.

00:21:58.924 --> 00:21:59.446
Basically.

00:21:59.646 --> 00:22:00.369
As a reference.

00:22:00.760 --> 00:22:16.132
I pasted them in there and explained what I wanted to reach, what my expected results are, and then I just started to yeah, like a colleague, basically a co-pilot it's a pretty fitting word for that to just do pair development basically.

00:22:17.121 --> 00:22:18.946
See that I'm going to do that.

00:22:18.946 --> 00:22:21.602
I'll try that later, so it saved you a lot of time.

00:22:21.863 --> 00:22:23.125
It sounds like versus right Well, this was.

00:22:23.125 --> 00:22:24.508
Yeah, it was an a lot of time.

00:22:24.508 --> 00:22:25.548
It sounds like versus right Well, this was.

00:22:26.210 --> 00:22:34.319
yeah, it was an example with high complexity and it would have taken me longer to wrap my head really around how to achieve the result.

00:22:34.319 --> 00:22:46.828
And in those scenarios, I think, where you're really looking at a high complex problem, it's helpful to get to a solution problem.

00:22:46.888 --> 00:22:47.932
It's helpful to get to a solution.

00:22:54.125 --> 00:22:54.988
It's like having another co-worker.

00:22:54.988 --> 00:22:58.453
I listened to several podcasts and I was listening to a podcast and they were talking about this.

00:22:58.453 --> 00:23:04.628
I definitely want to go back to this topic of the co-pilot chat because I have to.

00:23:04.628 --> 00:23:07.073
I'm going to start using it today to try some examples.

00:23:07.073 --> 00:23:15.539
But you mentioned, you know co-pilot is fitting because it is a co-pilot right If you're flying a plane, it's something that helps you.

00:23:15.539 --> 00:23:42.336
But you mentioned, it's almost like a colleague and I was listening to an entrepreneurial podcast and they were talking about software development and then also ai and software development and they were talking how the number of you know it increases the bar or raises the level of senior development and also this leaves space for a junior development.

00:23:42.336 --> 00:23:56.226
But there's that middle piece where you can reduce the number of developers you need because of something similar to what you just had mentioned is you could talk with Copilot, have Copilot, generate the code and then you do a code review.

00:23:56.820 --> 00:24:16.737
So it takes out a lot of that smaller, you know, time-consuming tasks and then you just have to do a review in essence, and I think you're doing a code review for Copilot, yeah, yeah, that, that, yeah so it's so it reduces the number of developers needed.

00:24:17.665 --> 00:24:18.367
And this wasn't.

00:24:18.367 --> 00:24:21.537
It wasn't related to AL in any way or Business Central.

00:24:21.537 --> 00:24:33.530
It was just they were talking about, you know, other standalone software applications you know that are available in the market and someone who started several software companies that's what he had said is said is it used to be.

00:24:33.530 --> 00:24:46.528
You know he would have a team of 10 and now he needed a team of three because ai was able to reduce the number of developers needed, because it could create a lot of the code for them yeah, it also.

00:24:46.729 --> 00:24:48.051
Uh, just another example.

00:24:48.051 --> 00:24:57.430
I just I just remembered, um, it's great if, uh, you have maybe code snippets from another language, just algorithms in Java or some JavaScript.

00:24:57.430 --> 00:25:06.674
That's really common that you see, you find some libraries or just take overflow stuff that's JavaScript and you want to have it translated into AL.

00:25:06.674 --> 00:25:14.096
I did that for a binary to hexadecimal conversion in AL native AL.

00:25:14.096 --> 00:25:15.317
That worked.

00:25:15.317 --> 00:25:17.191
I got that working.

00:25:17.191 --> 00:25:24.273
I would have never been able to write that on my own without days probably of learning how that works.

00:25:24.273 --> 00:25:31.654
Maybe not days now that I know how it works, but yeah, my copilot really reduced the time.

00:25:32.125 --> 00:25:50.061
That's a game changer for you know, stefan you mentioned, you know, as an independent consultant or independent developer, you know to have a co-pilot that allows you to provide more output of work with co-pilot.

00:25:50.061 --> 00:26:00.098
With Copilot, and it's like you hiring another person to help you without paying any benefits of some sort.

00:26:00.098 --> 00:26:11.112
And remember, I think last time we talked about how do you test each other's code or validate each other's code.

00:26:11.112 --> 00:26:17.329
I mean, you could potentially use copilot to test your code and vice versa as well.

00:26:17.770 --> 00:26:21.419
I think there are predefined questions in the copilot chat.

00:26:21.419 --> 00:26:25.191
That asks the chat to review your own code.

00:26:25.191 --> 00:26:27.355
I think that would be something possible.

00:26:27.375 --> 00:26:40.934
I need to try that actually that was one of the questions that I was going to bring up is is how can Copilot maybe help with that too, as far as going with the automation portion of it?

00:26:40.934 --> 00:26:43.272
But I have to do this Copilot chat.

00:26:43.272 --> 00:26:46.984
I'm excited now to try it, and it must be getting better and better with AL.

00:26:46.984 --> 00:26:53.439
I know, with what I see, with just the suggestions, with typing AL code, how good it's getting.

00:26:54.184 --> 00:26:56.493
Sometimes I wonder if it's reading my mind.

00:26:56.493 --> 00:27:00.133
I think it's already on GPT-4.0, if.

00:27:00.133 --> 00:27:04.053
I saw that correctly last time, so yeah, it's getting better.

00:27:04.424 --> 00:27:07.335
Yeah, but has it already been actually trained on AL?

00:27:07.335 --> 00:27:14.311
I think not, but that also got better.

00:27:14.311 --> 00:27:38.375
Yeah, of course it gets better over time and I'm seeing this myself, but it's not comparable to other old languages that the ALM has been trained on, and I'm really waiting for us to have this feature available as well that the co-pilot actually had learned, or has read, more AL lines than we have.

00:27:40.326 --> 00:27:40.487
Yeah.

00:27:40.487 --> 00:27:42.534
I think as more and more becomes available.

00:27:42.534 --> 00:27:43.951
I guess it has to learn.

00:27:43.951 --> 00:27:56.459
I don't even understand how it could learn it, because again you could type some procedures and some code, and how something can understand what it's doing is still.

00:27:56.459 --> 00:28:14.192
I'm not even going to try to understand how it understands to write code, because if you do you know a colon equals customer dot, get you know 1000 dot name or something like how does it know what you're doing or what you're trying to do?

00:28:16.029 --> 00:28:16.411
no idea.

00:28:16.411 --> 00:28:20.682
I think it's pattern recognition at a large scale, but uh, I I don't know.

00:28:20.682 --> 00:28:21.525
But I what?

00:28:21.525 --> 00:28:22.346
What I want to say?

00:28:22.346 --> 00:28:25.996
I I recently noticed that the co-pilot also picks up like it's.

00:28:25.996 --> 00:28:30.911
It's has something like to some degree in awareness of the of the entire project.

00:28:30.911 --> 00:28:39.891
So I'm getting recommendations for like for code that is present in other files I had opened recently.

00:28:39.891 --> 00:28:45.772
So when I switch files it somehow picks up what I was looking at before and adapts.

00:28:45.772 --> 00:28:47.599
So that was something I did.

00:28:47.599 --> 00:28:51.288
I noticed that it wasn't there before and it got introduced at like.

00:28:51.449 --> 00:29:04.494
I don't know when, but recently yes, now I'm my mind is going all over the place with this and, natalie, you'd mentioned that you're using it in your organization for documentation.

00:29:04.494 --> 00:29:06.923
Are they documenting the code?

00:29:06.923 --> 00:29:14.298
Is it something where you could have an al file and say, summarize or create notes for this file?

00:29:15.326 --> 00:29:17.575
I think this has already been created.

00:29:17.575 --> 00:29:19.913
We have our own ALM for that.

00:29:19.913 --> 00:29:28.854
So there's a company, an internal machine, let's say, and it does really a lot.

00:29:28.854 --> 00:29:34.373
It has been trained for just like that and the results are really, really, really good.

00:29:35.346 --> 00:29:41.479
I have to try that because documentation is one of the worst things to do, I think, and nobody does it.

00:29:41.704 --> 00:29:45.997
But it doesn't mean that there are still not other manual processes that it cannot replace.

00:29:45.997 --> 00:29:47.730
This is actually the case.

00:29:48.506 --> 00:29:51.756
But if it can do 80% of the documentation, I'm happy.

00:29:51.756 --> 00:29:58.976
And that's what I keep saying is I am not one, and I'll say over and over again I do not think AI is a replacement for things.

00:29:58.976 --> 00:30:11.796
I think AI is a tool that somebody can use to do a job a little quicker, just like I keep saying over we have a hammer or we have an air gun.

00:30:11.796 --> 00:30:16.625
You know to place a nail, you have a screwdriver and you have a hammer.

00:30:16.625 --> 00:30:19.195
You know which tool do you use for the job.

00:30:19.195 --> 00:30:26.797
You just have to choose the appropriate, but you still need someone to manage it or oversee it, in a sense, and what level it all depends on.

00:30:26.797 --> 00:30:33.653
You know the task that you're doing as well, which is interesting.

00:30:33.653 --> 00:30:37.018
So back to the.

00:30:37.018 --> 00:30:38.861
I don't want to talk about this co-pilot thing.

00:30:38.861 --> 00:30:43.542
That wasn't the intent of the whole thing, but I'm, I'm, I'm hung up on this co-pilot.

00:30:43.845 --> 00:30:52.875
I was just curious about the efficiency because it's been thrown, you know, around quite a bit and I'm just curious from every other areas of how it's being used.

00:30:52.875 --> 00:31:04.917
So I appreciate the both of you you know, sharing where it fits into your day to day and, of course, being able to adopt to it, you know, to your day to day task.

00:31:04.917 --> 00:31:08.575
So good insight, I appreciate it.

00:31:08.575 --> 00:31:12.450
Yeah, I want to open up Because we're trying to figure it out.

00:31:13.105 --> 00:31:23.174
No, I have some things that I'm working on that I'm thinking that if this can do this for me, I didn't even think of using the chat I have to Stefan on one stream.

00:31:23.174 --> 00:31:28.371
Can you just dedicate one to just the chat and have it create a whole app for you?

00:31:31.249 --> 00:31:32.432
I mean, I can certainly try.

00:31:32.884 --> 00:31:34.330
Yeah, we'll come up with an idea.

00:31:34.330 --> 00:31:38.736
Let's do that and we'll come up with an idea and see what AI creates for you.

00:31:38.736 --> 00:32:01.247
If you said if it mentioned I saw the JSON wrapper that you had posted something similar, maybe we can do like we'll have to do something creative to create an app and see what it comes up with in AL for us for us and Brent, just as a tip, in my second let's Block post I actually posted about how I used the GitHub Copilot chat to create these regular expressions for me.

00:32:01.407 --> 00:32:06.652
So it's not full of screenshots or something, but it's only textual.

00:32:06.652 --> 00:32:08.833
But it should also get you along.

00:32:09.204 --> 00:32:10.008
When did you post that?

00:32:10.008 --> 00:32:10.930
And I didn't see that.

00:32:12.314 --> 00:32:13.645
When was it Last week, two weeks ago?

00:32:13.645 --> 00:32:13.825
I, I didn't see that.

00:32:13.825 --> 00:32:14.305
When was it Last week?

00:32:15.465 --> 00:32:16.727
Two weeks ago.

00:32:16.727 --> 00:32:20.270
I'll tell you why Because I was on vacation last week.

00:32:20.451 --> 00:32:22.233
How dare you?

00:32:22.273 --> 00:32:28.861
Yes, the one time I took a vacation and I, honestly, I did not keep up with anything.

00:32:28.861 --> 00:32:41.328
I checked emails here and there just to see if there's any emergency, but I told myself it's going to be a vacation from everything, and then a hurricane came and cut it short, so I wasn't meant to take a vacation.

00:32:41.328 --> 00:32:43.333
Yeah, see.

00:32:45.298 --> 00:32:48.434
Yeah, the world's telling him you need to go back to work.

00:32:48.434 --> 00:32:50.467
Yeah, I'm thankful that.

00:32:51.208 --> 00:33:02.320
I didn't suffer any damage or have any issues, but we had to cut the vacation short to ensure that we got away from any of the horrible damage of the hurricane.

00:33:02.320 --> 00:33:10.737
I was extremely disappointed because I had a lot of things planned and I guess Mother Nature didn't want me to have that fun.

00:33:10.737 --> 00:33:17.269
I still took the vacation, though I just did other things other, uh, other than what I had planned to do, uh, in the water.

00:33:17.269 --> 00:33:21.965
So I will go back and read that, though, um, and that's why I missed it.

00:33:21.965 --> 00:33:22.386
So that's a.

00:33:22.386 --> 00:33:26.195
At least I don't feel as badly now because I do read what you have.

00:33:26.195 --> 00:33:30.750
Uh, you're on my list and I see the post that you create.

00:33:30.750 --> 00:33:35.156
So, um, the post that you create.

00:33:35.156 --> 00:33:36.640
So I'll look at it afterwards.

00:33:39.144 --> 00:33:44.633
I have used Copilot, though, on some of these posts not yours to say give me the summary of this as well.

00:33:44.633 --> 00:33:45.910
And even on emails.

00:33:45.910 --> 00:33:50.530
You know, when I was away, for example, there's email threads.

00:33:50.530 --> 00:33:53.375
I didn't realize that you could highlight all of the emails and say I did realize, I tried it and summarize this for me.

00:33:53.375 --> 00:33:53.710
Example there's email threads.

00:33:53.710 --> 00:33:57.097
I didn't realize that you could highlight all of the emails and say I did realize, I tried it and summarize this for me.

00:33:57.097 --> 00:33:59.001
So those 10, 15 emails.

00:33:59.001 --> 00:34:07.237
It just created a summary for me and it was quite accurate, so I appreciated that as well.

00:34:07.758 --> 00:34:19.833
We're using these summaries also on meetings and for support requests that come to us, and what I'm seeing sometimes is that the summary is wrong in some details and you have to be careful when you read this.

00:34:21.465 --> 00:34:23.052
Yes, that is key.

00:34:23.052 --> 00:34:27.115
You have to validate and make sure that it makes sense.

00:34:28.925 --> 00:34:32.896
Oh well, I think it works okay.

00:34:32.896 --> 00:34:34.788
So let's go back to our.

00:34:34.788 --> 00:34:37.653
Did you come back with your topics that you want to talk about?

00:34:37.653 --> 00:34:38.655
Stefan, for the code review?

00:34:38.655 --> 00:34:44.032
No, I'm having fun with the conversation.

00:34:44.032 --> 00:34:57.701
My mind is now thinking about Copilot and the code reviews and the process and the code reviews and the process.

00:34:57.701 --> 00:35:01.610
Now, when it comes to code reviews, who should do the code review?

00:35:01.610 --> 00:35:02.994
I know it's somebody else that's in there.

00:35:02.994 --> 00:35:08.652
I noticed, stefan you talked about last time that sometimes you would take a look at your own because you're doing a lot of the independent consulting.

00:35:08.652 --> 00:35:11.474
But within an organization, who should do the code reviews?

00:35:11.474 --> 00:35:16.967
I know that it can be a learning tool for some developers.

00:35:16.967 --> 00:35:20.985
You know I found some having them take a look at code doing code user work with them.

00:35:20.985 --> 00:35:24.253
They were able to learn from seeing code of others.

00:35:24.253 --> 00:35:39.876
But is there a a particular level of developer that should do it or a particular person in an organization that should do it, and how can we define the rules of what they do for a code view?

00:35:39.916 --> 00:35:40.677
I'm still stuck on this.

00:35:40.677 --> 00:35:43.172
I don't know if I'll ever get the answer.

00:35:43.172 --> 00:35:44.871
It's similar to what you say with the clean code.

00:35:44.871 --> 00:35:52.295
I don't know if you ever get there, but for a code review, how can you come up with the rules for what someone should look for?

00:35:55.047 --> 00:35:55.911
That's difficult.

00:35:55.911 --> 00:36:29.097
In our organization it's mostly a team member and in web cases, when, for example, somebody externally requested a feature from me and I am then pushing it to a pull request, then the requester if he's also a programmer, then I'll let him check it again, but usually it's just somebody from the team, and if I need to choose from my team members then I tend to those who are as nitty as I am.

00:36:29.097 --> 00:36:31.815
I still call you nitty.

00:36:32.626 --> 00:36:33.449
I still call you nitty.

00:36:33.489 --> 00:36:43.976
by the way, you'll always be, you know I think, um the there is no ideal reviewer.

00:36:43.976 --> 00:36:50.018
I think everyone should engage in code reviews and everyone should get reviewed, like the seniors.

00:36:50.018 --> 00:36:55.641
Senior should get reviewed, maybe by junior, just to get new ideas.

00:36:55.641 --> 00:36:57.547
Like why are you doing this stuff like this?

00:36:57.547 --> 00:37:00.996
And just because they did it like this the last 20 years is not an answer.

00:37:00.996 --> 00:37:05.072
There should be a reason or learning vice versa.

00:37:05.132 --> 00:37:13.210
So, um, yeah, probably just everyone, everyone that is a good point because, um, you know, I I don't.

00:37:13.210 --> 00:37:20.840
I don't believe that it has to be a senior developer doing the only review.

00:37:20.840 --> 00:37:24.755
I think, like Stefan, like you said, everyone should be involved.

00:37:24.755 --> 00:37:55.228
It does give you more of a collaborative approach to a solution that you're building, to a solution that you're building, and you'd be surprised that some junior developers may have a different perspective, especially the ones that are maybe coming from a different language or code language, because we all know that ALs continue to evolve and become more and more modern, that they may have a different perspective, especially if they're coming from a different language.

00:37:55.228 --> 00:38:07.105
But, good, good, call out on there that everyone should be able to have a chance to review someone else's work, even though you've only been doing it for a short period of time.

00:38:07.907 --> 00:38:19.498
no, I mean maybe the maybe the question would be if a junior should be the only reviewer of a junior developer, then you could maybe think about pulling somebody else into review in addition.

00:38:19.498 --> 00:38:23.824
But yeah, I think everyone should engage.

00:38:24.947 --> 00:38:38.835
You hit the key point of the 20 years and, chris, your topic too, because that's sometimes some of the struggles that I've seen is the old way for those that have been working with Cal, for example.

00:38:38.835 --> 00:38:47.014
Sometimes those habits I guess you could have with that, and I think we mentioned it last time can be dangerous.

00:38:47.014 --> 00:39:20.414
So having somebody with a fresh set because it's a fresh mindset could also help with the coding as well too, because some of the coding has become easier because of the addition of different data types or different features added to the AL language, that something that was done 20 years ago, 15 years ago may not be the same A good example would maybe be the name value buffer.

00:39:21.405 --> 00:39:26.429
It was common and best practice a few years ago that we got dictionaries.

00:39:26.429 --> 00:39:30.454
Now it's yeah, there are still use cases for that table.

00:39:30.454 --> 00:39:35.711
But yeah, if I just see it randomly in code, I will probably ask why are you using this?

00:39:35.711 --> 00:39:38.391
Why are you not using dictionaries?

00:39:38.391 --> 00:39:39.771
If there is a reason, fine.

00:39:39.771 --> 00:39:45.387
If there is not, maybe it just out of habit was used or whatever.

00:39:45.387 --> 00:39:46.431
But yeah.

00:39:49.226 --> 00:40:01.655
I'm still thrilled that they added lists and dictionaries so that we didn't have to use all those temporary tables or those, as you call them, like the buffer tables to move a lot of information around.

00:40:04.766 --> 00:40:06.268
So a quick question now.

00:40:06.268 --> 00:40:17.018
You know, with new features coming in, you know how do you like I think you guys clearly put this out there earlier that it's hard to achieve clean code.

00:40:17.018 --> 00:40:27.193
I mean, how do you maintain clean code when new features comes out or new functionalities come out, right, so how do you even keep up?

00:40:27.193 --> 00:40:35.474
I think that's the bigger component, and you know, do you go back and make adjustments?

00:40:35.474 --> 00:40:45.400
You know, is there a process within your areas that you go back, say this new feature came out, we should adjust this.

00:40:45.400 --> 00:40:51.472
You know, is there a process or cycle that you have you go through to clean up because of new features?

00:40:54.697 --> 00:41:12.775
My apps, as per AppJSON, are based on the current or at least the pre-latest BC version outside, so I can use the latest features usually and whenever I upgrade to a new BC version.

00:41:12.775 --> 00:41:27.961
So when I'm raising the minimum BC version for my app, then I always check what are the new features and I try to uptake them as much as possible.

00:41:27.961 --> 00:41:30.771
And for the question, how do I keep up with that?

00:41:30.771 --> 00:41:41.393
Well, I actually create blog posts for them where I gather all the development stuff in one post so I can go through it, like through a list, and then that's it.

00:41:41.393 --> 00:42:06.552
This helps me at least, but this can be done, of course, only if your app is already almost up to date, because if you're having an app that is, for example, based on a really old PC version though maybe still supported, but old then you have other interests to keeping this app up to date.

00:42:06.592 --> 00:42:17.458
Maybe, but in any way the usual programmer doesn't see so much of the new features.

00:42:17.458 --> 00:42:29.364
They are relying on somebody telling them what are the new features, like we are getting to know next week in the BC launch event, for example, or through blog posts or whatever.

00:42:29.364 --> 00:42:38.331
I, from my side, get everything from the docs, where it's really written, and and the change logs and so on.

00:42:38.331 --> 00:42:43.706
This is all the nerdy stuff that I really love to read, but then I try to summarize them for you guys.

00:42:43.766 --> 00:42:53.536
So, um, this is how I try to keep up to date yeah, just today I read your blog post on what's new in v15.

00:42:53.536 --> 00:42:58.161
Or it's 25 and compiler 14.

00:42:58.161 --> 00:43:03.153
So, yeah, and my take on that.

00:43:03.454 --> 00:43:10.177
Sorry, I laugh at that, because those numbers always throw me too.

00:43:10.177 --> 00:43:13.434
It's like it's 25, but it's 2024, wave 2.

00:43:14.085 --> 00:43:22.338
It's runtime version 14, but 13 is it's microsoft should just jump the compiler version to align with bc version.

00:43:22.338 --> 00:43:30.445
That would be do 26 in april, in april and everybody's you have my vote that has my vote too.

00:43:30.985 --> 00:43:33.769
It absolutely has my vote, and they could just pick it up from there.

00:43:34.791 --> 00:43:41.980
Yeah, and my take on this is a little bit depending on the feature, so I do not go back to all like change all the code.

00:43:41.980 --> 00:43:44.806
It depends a little bit.

00:43:44.806 --> 00:43:57.264
For example, read isolation was introduced, which can potentially improve performance quite a bit, and I try to use it everywhere, going forward when I write new code quite a bit, and I try to use it everywhere, going forward when I write new code.

00:43:57.264 --> 00:44:03.965
But if I would go back and apply this to all the find statements or every code read that's in an app, then I could introduce potential bugs.

00:44:03.965 --> 00:44:05.570
So then I'm careful.

00:44:05.570 --> 00:44:11.458
If there is not a problem that I need to fix, then I would not go back and introduce this.

00:44:11.458 --> 00:44:14.476
If, for example, with the set load fields, I would much rather go back and introduce this.

00:44:14.476 --> 00:44:30.048
If, for example, with the setLoadFields, I would much rather go back and apply this everywhere, because, first of all, there is a quick fix to do this and second, if I'm looking at the local variable that's not passed in as parameters, then I'm pretty sure that I can definitely know which fields are needed.

00:44:30.048 --> 00:44:35.728
And then perorf's blog post it's even better if there are JIT loads than not using it at all.

00:44:35.728 --> 00:44:53.898
So there is not really potential to break code if I do this change and I could potentially really increase performance when I'm applying this to the base tables, like sales header or items with lots and lots of fields where I just need maybe two or three fields of them.

00:44:53.898 --> 00:44:56.987
So really, for me it depends on the feature.

00:44:57.610 --> 00:45:07.436
But I just today enabled the warning for the, like the, the analyzer warning for the, this keyword, to have it always in front of.

00:45:07.436 --> 00:45:08.972
So I'm working on a project.

00:45:08.972 --> 00:45:11.673
I just increased the runtime today to 14.

00:45:11.673 --> 00:45:13.940
So I can, I can use this, this, and I just switched the runtime today to 14.

00:45:13.940 --> 00:45:19.769
So I can use this and I just switched the warning on so I can update this and get reminded to use it everywhere.

00:45:21.494 --> 00:45:21.695
Cool.

00:45:21.695 --> 00:45:32.074
I cannot pick that up as quickly as you, because I usually release my apps for the new BC version a few months, maybe later.

00:45:33.865 --> 00:45:36.215
It's a new app that's not yet on AppSource.

00:45:36.215 --> 00:45:42.577
I'm just working on new stuff and then there's no sense in doing version 13 anymore.

00:45:48.369 --> 00:45:48.972
I want to do that.

00:45:48.972 --> 00:45:50.672
I'm going to bump it up today too.

00:45:50.905 --> 00:46:06.235