Vjekoslav Babic
Solutions Architect | MVP
Zagreb, Croatia
Actions
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".
Awards
Area of Expertise
Topics
TDD on autopilot: Letting Copilot Take the Wheel
In the AL world, Test-Driven Development has about the same appeal as a manual year-end closing. It's been pushed aside, labeled as that thing that "sounds great in theory" but takes too much time in practice. But what if I told you GitHub Copilot could turn TDD from your least favorite chore into your secret productivity weapon?
This session shows how Copilot doesn't just write tests - it helps you craft code that practically tests itself. You'll see how the right structure makes Copilot an eerily accurate test writer, transforming that "red-green-refactor" cycle from a marathon into a sprint. No more staring at blank test files wondering where to start.
You'll see how Copilot works on the inside, and -- armed with that knowledge -- how to use it in the most productive way to have it always propose exactly that code that you would write yourself, just in far less time, and without trial and error.
Join in, and let's put Copilot in the driver's seat - autopilot for your test suite, if you will.
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
When unit testing meets AL, you're in trouble. Or are you?
This session delves deep into the world of test doubles, and you'll get to meet the whole gang: from dummies playing dumb to spies sniffing around your code, from stubs repeating themselves like a broken record, to mocks with serious control issues, and fakes trying their best to convince everyone they are the real deal.
But it's not just about the test doubles. This is where it gets interesting: there's an epic rivalry between the Detroit and London schools of testing thought (spoiler alert: it's less about cars and tea, more about code). You'll discover how these competing philosophies tackle those awkward dependency situations, and what to do when private members get a bit too... private.
Through real code examples and industry-proven practices, we'll explore how to write tests that actually make sense without making you want to pull your hair out. Whether you're team Detroit or team London, or somewhere in between, you'll learn to navigate the testing landscape with confidence, tackle dependencies like a pro, and make your code testable without breaking a sweat.
Even if you caught this session before, there's fresh content and new perspectives to keep you on your toes. Because let's be honest – in the world of AL testing, there's always room for a double take.
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