After a lot of fun with interfaces on Friday, I’ve received a lot of very encouraging feedback. It seems that the decision to start live video blogging was right, and I am sticking with it.
I’ve realized that on Friday I didn’t announce any schedule for the period ahead, so here’s what we are going to do in coming Fridays.
Today I’ve streamed the Fun with Interfaces video blog at https://www.youtube.com/watch?v=QSMHL32c5mg and the recording is now published online.
This was the first session I ever delivered about interfaces, and I actually planned delivering this a lot earlier (I made a suggestion to run this at Directions ASIA before corona crisis hit), but never had a chance. I now polished the demos a bit and delivered it as-is (no slides, really, so – no theory, just practice).
I will have more to say on interfaces, definitely. Stuff like dependency injection, inversion of control, testability, etc. is all very interesting to discuss and very useful in our daily life with AL.
My today’s session not only shows what you can do with interfaces, but also what you cannot, and why. Maybe, who knows, at some point we get some improvements to address some of pain points from my video.
Thanks to everyone who joined me today, and I am looking forward to see all you next week in “Making InvokeExtensibilityMethod work” session.
Source code files are living things. We add new ones and change their content on daily basis. Occasionally we delete them, too. Git is amazingly efficient when it comes to tracking these kinds of changes.
However, sometimes we need to change the file name, or file path, or both. And if you are an AL developer who has ever transformed a C/AL project into AL, you have probably done this at least once, for all .al files in the project.
And this is where git may surprise you. After you rename a file, sometimes you’ll notice that git detects it as a rename. But on other occasions it will not be the case.
Let’s dive in.
A lot of us still have a ton of C/AL code sitting around in existing databases that sooner or later will have to be moved into AL. A lot of us also have a ton of AL code using DotNet that we want to be able to run in Microsoft’s cloud (that is: not on-prem). And I guess most of us don’t want to maintain a DotNet-less and DotNet-ful versions of our code.
Sooner or later, you’ll want all of DotNet out of your AL. Even if you are a seasoned .NET developer, you’ll want all DotNet out of AL.
Anyway, when you need to replace DotNet, what options do you have? Let’s take a look at all possible paths.
Thanks to everyone who watched my live stream today! The audience wasn’t big, but it’s a very narrow topic, not of broad interest. Still, I am glad I got a few interesting questions that actually introduced my future topics quite nicely.
You can find the recording here:
As promised, I have published the GetImageResource.js file on my GitHub. You can find it here:
https://github.com/vjekob/RandomBits/tree/main/src/js
(There you can also find some usage notes and explanation why you may want to use that file in your control add-ins)
Once again – thanks, and see you next week in a topic that should draw a lot more audience: AL interfaces!
Thanks to everyone who attended my live blog yesterday, and to everyone who subscribed. It was so encouraging to see that you like this idea.
As announced yesterday, my live blog will run on a fixed schedule – every Friday, at 14:00 CET (8:00 AM EST) I’ll get online to present a topic and discuss it live with you. This is the schedule for the next two Fridays:
This is going to be a live coding session. I’ll take a working control add-in developed in a mish-mash of tools we used to develop them back in the stone age, and migrate all that into AL. I’ll present two viable approaches for this, that I’ll call a “white box approach” and a “black box approach”.
While doing this, I’ll also discuss what can be done, what can’t be done, and things you want to watch out for while performing the migration.
Again, a mostly live coding session. I’ll present AL interface type, what it’s good for, and how to use it. Of course, I’ll address the usage through enum type, but I’ll also talk a lot about other use cases. Interfaces allow us to fix some old and long-standing anti-patterns, and introduce some nice new patterns, and you can expect me talking about that, too.
It was great to see that – when I asked about what topics you’d like to see me cover – there were both interfaces and design patterns in AL. It tells me we are on the same page here.
I have no firm plan for December yet. I actually want you folks to have most of say in what my live blog will be about. Yesterday, you gave me some ideas and today I want to let you choose.
In the poll below, select up to two topics you’d like me to cover in the first two live slots in December.
[poll id=”2″]
The poll runs until noon on November 19th, the top two answers will be my topics for December 4 and 11.
Other than the topics you (will/have) suggest(ed), I have a few topics of my own that I’d like to bring some attention to:
AssertError Error('') for a long time, and now we don’t (really) have it anymore. We need to fall back to (or simply keep relying on) if Codeunit.Run(). But this is very limited in terms what and how we pass state between caller and callee. This will be a “let’s code and theorize together” kind of session, more about discussing what we have and where we would like to go from here and why, than presenting actual “how to this or that”.Let me know in the comments what other topics you’d like me to cover, and also what you think of these topics I suggest here. Enjoy the weekend, and see you next Friday!
It’s time to turn a new page.
You’ve noticed that I’ve been absent for a long time. No posts, no activity. Well, blogging takes time, and I am a sort of a perfectionist. Writing posts sometimes takes hours, there have been posts that took me days. Let me not mention how many articles sit unfinished. Most of them make no sense at all to complete anymore.
I was thinking of video blogging. Eric Hougaard has a pretty cool video blog, and he actually inspired me to start thinking in that direction. But having created dozens of videos myself, and being perfectionist and all, creating videos takes a lot more time than writing posts.
So, I’ve decided to try something else: live blogging. Yeah, right, I always get on a train five years after it takes off, but better late than never, they say.
To make the long story short, today at 15:30 CET (that’s 3:30 PM EST) I kick off.
The place you want to be is https://vjeko.com/live or you can simply scan the QR code below.
Good. If you want to know how this new live blog will work, I invite you to join me today, or to watch the recording afterwards. No spoilers, no trailers. Just pure BC fun (Sheldon Cooper style 🤣)
See you in the cloud!
The community often criticizes Microsoft for adding new platform features only when Microsoft needed them. Well, it has been a bit too harsh – Microsoft did add improvements in other situations, too. But still, if you compare it to other Microsoft’s languages like TypeScript or C#, the AL language isn’t really advancing.
Looking back at C/AL, the AL language has really brought a lot of improvements. We have native JSON types, HTTP API, interfaces, overloads, and a lot more. But still, the overall change of the AL language was minor improvement, rather than a real evolution that transition to VS Code could have allowed.
Here’s the list of top five things I’d absolutely love to see in AL. And I have strong reasons to believe that all of them would be fairly easy to implement for Microsoft. Let’s get started.
I’ve never truly understood why we could explicitly commit a transaction, but we could only implicitly roll one back. There is a universe of difference between throwing an error (and ending the call stack), and rolling back (and continuing execution).
There was always a way to roll back and go on, sure. Wrap the entire thing in a if Codeunit.Run() block, throw an error as the last thing inside that codeunit, and there you go. Problem solved. Well, not quite.