git

Read more about the article Inside Git: Branches

Inside Git: Branches

  • Reading time:2 mins read

It has again been a while since I blogged – or video-blogged for that matter. I won’t offer any excuses – I’ve been very busy over the past month. I delivered two public webinars, both of which were fully booked and ended up very successful. The first one was Leveraging Git, and it was the first public redelivery since January. The second one was CI/CD from AL Developer’s Shoes, and this was the first iteration of this one that practically consumed all free time I had. That one is to blame for me not blogging or broadcasting for more than four weeks.

Cool, now that I am done with the excuses, it’s time to move on. Today I’ve finally had time to go live again with a new episode of Vjeko.live. Since I am so busy with Git these days (and webinars are only a part of my being busy with Git, in fact), I’ve decided to deliver another short “inside Git” session. This time it was branches, and I went into what branches actually are in Git, how Git stores them, what happens when you create a branch, check out a branch, or delete a branch.

If you missed the live broadcast at 4PM today, you can follow it at your own convenience here:

If you want to learn more about branches, don’t miss my next public webinar in two weeks: Git Branching Models and Strategies.

See you in the cloud!

Continue ReadingInside Git: Branches
Read more about the article Git storage – SHA1

Git storage – SHA1

  • Reading time:18 mins read

If you have ever worked with Microsoft’s Team Foundation version control tools, it wasn’t easy to switch to Git. That’s not because Git was complicated – no, nothing like that at all! It was simply because you had to forget almost everything you thought you knew about version control, and then learn it anew.

There are many fundamental differences between Git and TFVC, and one of the more obvious ones to any newcomer to Git is this:

If it wasn’t obvious on the first go, TFVC is on the left, Git is on the right

No, it’s not about the caption here. Indeed, TFVC calls individual snapshots of changes “changesets” and Git calls them “commits”, but that’s just terminology – the term in itself is not a fundamental difference. I am after something else here.

Continue ReadingGit storage – SHA1
Read more about the article Webinars in the upcoming period

Webinars in the upcoming period

  • Reading time:10 mins read

My last two webinars were a great success, and this is not only judging from my angle. Attendees were very happy with them, and the feedback I received was overwhelmingly positive. I’ve got a lot of inquiries about repeating them, and I also got a few ideas for new ones that would allow you to build on top of the knowledge gained in the first two.

So, today I am announcing the schedule for the webinars for the next three months.

Continue ReadingWebinars in the upcoming period
Read more about the article Webinar: CI/CD from AL developer’s shoes

Webinar: CI/CD from AL developer’s shoes

  • Reading time:3 mins read

I am postponing this webinar! It appears that it coincides directly with a webinar held by Arend-Jan Kauffmann, so I’ll announce different dates for this one soon.

This webinar is moved to May, please check the sidebar.

After two very successful webinars about Git internals and Git branching models and strategies, I am now announcing the next one, titled CI/CD from AL developer’s shoes.

When talking about CI/CD, one word typically pops to mind: pipelines. But pipelines is just one aspect of this much wider and bigger topic. Let me just say this: Continuous integration was conceived a long time before anyone was thinking of pipelines. Continuous integration and delivery are sets of practices, a philosophy if you want, that must go through into every pore of the development process before pipelines can make much sense.

And while previous two webinars were almost agnostic of AL, and were presenting Git and related processes from nearly a pure Git perspective, this webinar has AL in central focus, and presents this important topic from the angle of an AL developer.

Continue ReadingWebinar: CI/CD from AL developer’s shoes
Read more about the article Webinar: Git branching models and strategies

Webinar: Git branching models and strategies

  • Reading time:2 mins read

A few days ago I’ve announced that there will be a new series of webinars. The last webinar was a success. Apart from a few people complaining that I talked fast, and that there was too much content, I got pretty good comments. People felt quite happy with the content and that the value they received was worth the money they invested.

One thing I’ve learned was that you want to learn more about various branching models and strategies. One thing is talking about Git from the technical angle – that’s what the last webinar was about; this time I am focusing on the strategy, how to make Git work inside your organization and how to organize your repository and workflow.

Continue ReadingWebinar: Git branching models and strategies

Schedule for the period ahead

  • Reading time:4 mins read

Happy New Year everyone, with a little delay. I was busy in the first two weeks of this year preparing and delivering the “Leveraging Git” webinar. It turned out to be quite a success, but it also prevented me from doing my live session last Friday.

But this short break doesn’t mean I am not going to get busy with my blog and live blog again. This is what’s coming up.

Continue ReadingSchedule for the period ahead
Read more about the article Webinar: Leveraging Git

Webinar: Leveraging Git

  • Reading time:2 mins read

It’s been a few days that I announced the “Leveraging Git” webinar on my Twitter and LinkedIn and I hope nobody will mind if I announce it on my blog.

So, here we go.

Every year I deliver between five to ten trainings. This year, I delivered a grand total of zero, due to the coronavirus outbreak. Times are changing, and I need to adapt. So, following the example set by my two friends, Waldo and AJ, who have already delivered webinars, I have decided to try the same.

The webinar focuses on Git as an essential development tool, rather than just a way to replace those ugly //BugFix.425> code annotations we were all used to in C/AL. Apart from creating a branch (when absolutely necessary), committing (often rarely), and perhaps merging (once in a while, being scared of it), most developers don’t do much more. Many don’t even know what power lurks beneath.

This webinar sheds light on Git, explains its internals, and arms you with new tools and knowledge to take Git to the next level, a level where not only you are using Git, but where you are leveraging it, day in, day out.

To learn more about the webinar, and to sign up, click this button:

Learn more and sign up!
Continue ReadingWebinar: Leveraging Git

Understanding renaming/moving files with git

  • Reading time:11 mins read

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.

Continue ReadingUnderstanding renaming/moving files with git
Read more about the article Code annotations in AL – Please, don’t!

Code annotations in AL – Please, don’t!

  • Reading time:10 mins read

One of good practices of writing C/AL Code for Microsoft Dynamics NAV since the dawn of civilization was annotating (commenting) code changes. If you are not sure what I mean by that, this is what I am talking about:

While standards varied about > vs +, or < vs -, or what the annotations should include, there was absolute consensus that annotating changes is an absolute must.

And it was a must. It was such an important rule that everyone followed it without questions asked. In my career, I’ve seen one or two situations of somebody changing or deleting a line of code without leaving any comment, and I’ve seen quite a lot of code, believe you me. It was that important.

It was that important in fact that it was one of the first things developers learned when they signed up for the job, and it was one of the rules they all followed from their first day.

Continue ReadingCode annotations in AL – Please, don’t!