At Directions in Lyon last year, I took a slight detour in the presentation to talk about being conscious about how you work. Lots of folks have asked me to talk about this on the channel. Check out the video:
In this video, Erik kicks off 2024 with a focused discussion on developer productivity — specifically, how AL developers can optimize their inner loop to work faster and more efficiently. Drawing from a session he gave at Directions in León, Erik breaks down the concept of the developer’s inner loop, explains why it matters, and shares practical tips for minimizing wasted time in your daily coding workflow.
The Developer’s Inner Loop
The concept of an “inner loop” comes from a classic computer science idea: in any process, the innermost loop is the one that executes most frequently. Because it runs so often, even small inefficiencies compound dramatically. The same principle applies to how we work as developers.
Erik describes two loops that define the developer workflow:
The Inner Loop: Code → Build → Deploy → Debug
This is where you spend the majority of your time as a developer. The cycle looks like this:
- Code — You write or modify AL code.
- Build — The extension compiles.
- Deploy — The extension is published to your development environment.
- Debug — You test and verify whether your changes work as expected.
You repeat this cycle constantly — sometimes for hours or days — until you have something that works and solves the customer’s problem. The key insight is that your build and deploy time should take as little time as possible. Every second you wait in this loop is time you’re not productively coding.
The Outer Loop: Commit → Code Review → Test → Compliance → Release
Once you’re satisfied with your work, you commit and move to the outer loop. This is a fundamentally different mindset. In the outer loop, you’re doing code reviews, running full test suites, deploying to testing environments, and verifying security and compliance. These activities are important but slow — Erik references a blog post by Waldo about test processes that ran for hours.
The critical point: you should not be living in the outer loop while doing inner loop work. You don’t want to write four lines of code and then wait for thousands of tests to run before writing the next four. That kind of context-switching destroys productivity.
The XKCD “Compiling” Problem
Erik references the famous XKCD comic strip about compiling — where a programmer’s excuse for slacking off is “my code’s compiling.” While it’s a great joke, it reveals a real problem: either the developer’s inner loop is terribly slow, or they’re constantly drifting out into the outer loop when they should be heads-down coding.
Practical Tips for a Faster Inner Loop
Get a Beefy Rig
AL is hungry for memory and CPU. The difference between a slow machine that builds your app in 25 seconds and a fast one that builds it in 5 seconds adds up dramatically over a full day of inner-loop iterations. You could easily waste 30 minutes to an hour per day just on slower build times.
If you’re a professional working with AL — and your hourly rate is at least three digits — there’s room in any budget for a decent development machine. Erik encourages developers to direct their bosses to this video if they need justification for better hardware.
Key hardware considerations:
- Fast disks — Disk speed is critical, especially with the many small files in a git repository.
- Sufficient RAM and CPU — AL compilation and Docker containers are resource-intensive.
- Dev-optimized OS — Microsoft is working on a special version of Windows optimized for development workloads, particularly for handling many small files.
Open Directly to Your Working Page
Erik demonstrates how pressing F5 in VS Code builds, deploys, and opens the exact page he’s working on — all in single-digit seconds. This eliminates the need to manually navigate through menus to find the right page and the right record after every deployment.
Here’s the sample extension Erik was working with, a page extension on the Customer List:
pageextension 50100 CustomerListExt extends "Customer List"
{
trigger OnOpenPage();
begin
Message(GenerateAwesomeMessage(TODAY()));
end;
local procedure GenerateAwesomeMessage(T: Date): Text
var
d: Integer;
m: Integer;
y: Integer;
begin
d := 3;
m := 4;
y := 5;
newProcedure(d, m);
end;
local procedure newProcedure(var d: Integer; var m: Integer): Text
begin
for d := m to m * 5 do begin
for m := d to d * 5 do begin
if d = m then
exit('Test!!!');
end;
end;
end;
}The launch.json configuration should be set so that F5 opens the specific page you’re working on — in this case, the Customer List. This way, every build-deploy cycle drops you right where you need to be.
Master Your Debugging Tools
Know how to work efficiently with breakpoints — including conditional breakpoints. Learn to inspect variables in the debug console quickly. The faster you can set up a debugging session, inspect state, and identify issues, the faster you complete each iteration of the inner loop.
Write Better Code (and Tests)
Erik highlights that testing deserves more attention in 2024. The more tests you write, the less manual debugging you need to do. He acknowledges that different developers have different processes — some think and code simultaneously, some work out solutions away from the keyboard and then just type them in. Whatever your process, be intentional about it.
Mindset: Know Which Loop You’re In
One of the most important takeaways is the mindset shift between the inner and outer loops. When you’re in the inner loop, you’re heads-down coding — deep focus, fast iterations. When you move to the outer loop after a commit, you need to consciously switch gears. Your time allocation changes: maybe two hours of coding, one hour for code review, one hour for build and deployment processes.
If you’re in a billing situation, make sure your billing reflects where you are in the process and what you’re doing. The inner loop and outer loop represent fundamentally different types of work.
Conclusion
The developer’s inner loop — code, build, deploy, debug — is where you spend most of your professional life as an AL developer. Optimizing this loop has an outsized impact on your overall productivity. Invest in fast hardware, configure your environment to minimize navigation overhead, master your debugging tools, write tests to reduce manual verification, and be mindful of when you’re in the inner loop versus the outer loop. These aren’t revolutionary ideas, but being intentional about them is what separates efficient developers from those leaving money on the table — whether it’s their own or their customer’s.
