Vjekoslav Babic
Solutions Architect | MVP
Zagreb, Croatia
Vjekoslav Babić, or just Vjeko as he prefers to go by in the community in a vain attempt to simplify his absurd Slavic name, is a Business Central architect, developer, trainer, author and blogger. With more than two decades of experience in the IT, he worked with vast range of technologies, but his passion has always been anything that had to do with the web and mobile worlds.
Deep down, Vjeko is an incurable hacker who took quite a long time to realize that the one thing he really loves is writing code, plain and simple. He immensely enjoys breaking things apart to see how they work, not necessarily always putting them back together. As a frequent speaker at conferences, in his demos, and on his blog, he is always pushing the boundaries of what's possible, connecting the world of Business Central with just about anything that can be plugged into it through some obscure loophole or undocumented interface, especially if they are not meant to be used that way. In Vjeko's view, nothing is really meant to be used in any particular way and figuring out how to make things useful beyond their intended purpose is the meaning of life, in a way.
Since spring 2010, Vjeko has been awarded the Most Valuable Professional (MVP) award for Microsoft Dynamics NAV. You can meet him at his blog "Vjeko.com - ideas in the cloud".
Links
Awards
Area of Expertise
Topics
Mythbusting code coverage (while writing better code)
Code coverage is one of rare useful metrics that can measure your code. Yet, most of us get it completely wrong.
Everyone knows that aiming for 100% coverage is crazy. So teams settle for some arbitrary figure they deem to be good enough. Most of teams aim for 80%, that's kind of an industry average.
Excuse my party-breaking, but why? Why is it okay to have 20% of code untested? How do you decide which 20% not to cover? More often than not, it's the most complicated 20%, and most impactful 20%.
For the better part of it, the 80% coverage is just a mantra. For some team, some time in the past, this figure made a lot of sense. But then it became one of those "best practices" that everyone follows, but nobody understands why anymore. The reason why it's okay not to test 20% of your code is not because it's your team's benchmark, but because that 20% of your code doesn't actually need testing.
This session shows you how to structure your code in such a way that there is a very clear split between code that needs testing, and the code that you can safely omit from your unit tests. The end result is a much more robust, more testable code, and a good test coverage that is not just some meaningless number your team settled for.
Double Trouble: A New Perspective on AL Testing
Let's face it, testing AL code isn't exactly the highlight of anyone's day. It's often seen as a chore – time-consuming to write and even more so to run. But what if it didn't have to be that way?
This deep dive session is going to change your perspective on unit tests. Forget the tedious integration tests; we're talking about the real champions – simple, fast, and accurate unit tests. They're your first line of defense against those pesky bugs and regressions. You'll see why they're so crucial and how they can actually make your life easier.
But the real game-changer? Test doubles. These are the secret sauce to making testing in AL a walk in the park. This session demystifies them for you – what they are, the different types there are, and the right time to use each one for maximum efficiency.
It's not just talk, though. You'll see a lot of code that will turn your view on both coding and testing upside down! You'll see how to tackle dependencies, and how to interact with the base and system apps in a clean, testable way. And yes, we'll answer that burning question: can you really trust test doubles and what is it that you are truly testing?
Join this session and learn how to elevate your testing game in AL. It's all about writing clean, efficient, robust, code and sharp, focused, meaningful tests that don't feel like a drag.
Case against 'case': how to write truly extensible code
Writing extensible code has always been a sort of a holy grail of Business Central, both for Microsoft and the ISV channel. Allowing third parties to extend your business logic without either interfering with your existing logic, or without relying on you to make changes on demand, has always been an issue. Recently, extensible enums seemed to allow free extensibility, but the practice has shown that marking enums as extensible is a big promise to make, and one that requires a lot more forethought than any other approach.
This session puts our existing practices under a big question mark, especially when it comes to the 'case' statement. Often perceived as a cornerstone of extensibility and intricate business logic, the 'case' statement paradoxically stands in opposition to the principles of clean code. While in AL 'case' seems natural and necessary, 'case' statements in fact indicate lack of design and lead to rigid, inflexible code structures that hinder extensibility and maintainability. Furthermore, the session scrutinizes the 'handled pattern', a prevalent approach in extensibility that, upon closer inspection, reveals itself as an antipattern that emerges as a necessary evil in scenarios where extensibility is more important than clean, maintainable, reliable, or testable code. In the end, all these practices lead to high cost of building, testing, and maintaining solutions.
Instead of only exposing the problems with existing approaches, this session provides alternatives at every step. You'll see how proper design and forethought coupled with some advanced coding practices and techniques can produce code that's easier to write and read, and also test, but that costs far less to maintain in the long run, and where extensibility comes as a natural, almost effortless outcome.
This session will profoundly change the way how you look at writing AL code, and you'll leave with with one question only: "why haven't I known all this before?" That's a promise.
ALchemy: Turning AL code into SOLID gold
SOLID principles are key to developing high-quality software, and they're just as relevant in the AL world as anywhere else. In this workshop, you'll see firsthand how applying these principles to Business Central development leads to more maintainable, flexible, better-structured code that stands the test of time and adapts easily to new requirements.
The workshop will focus on each of the five SOLID principles: it explains what they mean in theory, and shows how to apply it with a lot of practical, easy-to-follow examples in AL. The workshop follows a case study example, designed for a comprehensive hands-on experience, where you'll transform an existing AL solution written in traditional way into one that applies SOLID principles throughout. This isn't just about making minor adjustments; it's about reshaping the code entirely to make it more robust, easier to read and maintain, and efficient to test.
By participating, you'll gain valuable skills in enhancing the quality and testability of your AL code. This workshop is about providing you with the tools and knowledge to write Business Central code that is not only functional but also - well - solid, on every possible level, code that's ready for the cloud and the challenges of tomorrow's business requirements.
Prerequisites:
To attend this workshop you need a laptop, with access to a development environment (either an online sandbox, or local Docker) where you can deploy and develop without limitations.
JavaScript for NAV Developers
With an advent of web, and especially the tablet and the phone clients, it became obvious that we won’t be able to pretend the Web world has infiltrated our sacred C/AL ground for much longer. All the Web technologies, HTML5, CSS, and above all – JavaScript – have entered into our world and now we need to learn how to make this new animal behave in our own backyard. But JavaScript is not an easy beast to tame. Easygoing to the point of sloppiness, and flexible as a chewing gum, cryptic even before you minify it, as beautifl and elegant as it is cruel and scary, with functions that are variables that are also properties, and expressions, and at the same time behave as if they are all booleans, where everyting is either truthy or falsy, and where == was not good enough as an operator so it also came up with ===, if JavaScript gets you royally confused, don’t worry – it’s all by design.
If there was ever a language that was as powerful as to allow you to do absolutely any kind of craziness you could come up with, but at the same time allowing you to mess things up beyond all reason, then it’s JavaScript. It can do whatever you want it to do, and it’ll let you do whatever you want to do to it. And it now talks directly to C/AL, so you better get to know it well before it starts making fun of you.
This one-day workshop led by Vjekoslav Babić, who had been a seasoned Web developer for years before jumping on the C/AL wagon 15 years ago, you will learn all the intrinsics of JavaScript that can confuse an AL developer. Not only you’ll learn all the important language features such as callbacks and closures, or harness the immense power of expressions – you’ll also learn how to write efficient code, how to not make common mistakes, and how to take advantage of amazing development features embedded into every modern browser. And above all, you’ll learn how to properly use all this together with the good old C/AL.
Developing control add-ins using AL language
Control add-ins have been around for a long time, but a true breakthrough has arrived only with the AL language support for them. Building new control add-ins has never been easier, but there are still challenges to overcome, and best practices to observe, when building new, or porting old control add-ins to the AL language.
This one-day workshop, presented by a community veteran Vjeko Babić, will cover the development process for Control add-ins in AL language, end to end. It will arm you with all the necessary knowledge to build new control add-ins and make them blend seamlessly into your Microsoft Dynamics NAV and Dynamics 365 Business Central solutions
Azure Functions end-to-end
Developing and integrating serverless workloads is becoming increasingly more important in today's cloud-based architectures. Whether you are talking to a third-party API, or you need to extend your BC with functionality that AL language cannot achieve on its own, it's likely you'll need to reach for Azure Functions.
This comprehensive workshop covers the Azure Functions topics end-to-end. It explains how to create, manage, and maintain Azure Function apps, how to create functions using different languages and environments, how to manage different kinds of bindings such as storage BLOBs, tables, or queues, how to handle external function dependencies, how to invoke Azure services from within Azure Functions, how to configure security and access, how to deploy Azure Function apps (including CI/CD scenarios), and how to invoke Azure Functions from the AL language.
The workshop is full of hands-on practices so you will be very busy, and will learn a lot.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top