Check Your Assumptions, Know Your Defaults

A couple of weeks ago, I had a problem. It appeared that my refrigerator was failing to keep the cool food section, well, cool. Freezer was fine, but the thermometer I had in the cool food section was showing between 50-60 degrees F, which is far too warm.

This wasn’t the first time this had happened, and on previous occasions, the issue was ice buildup in the freezer that blocked the channel allowing cold air to move from the freezer to the cool food section. So I largely skipped over diagnosis, and jumped straight into trying to fix the issue by running a couple of defrost cycles. I also did a cleaning of the coils under the fridge which, thanks to our dog, were pretty nasty, in case that might be contributing to the problem.

I'll spare my readers a photo, as I would not want to cause any nightmares. Suffice it to say, if you have pets, check and clean your coils regularly.

Savvy troubleshooters among the readers may have already figured out where I’m going with this, but it turned out that the fridge was actually fine. I didn’t hurt anything by running the defrost, and I’m sure clearing the coils of dog fur made for more efficient cooling, but the central problem in this case was a sensor that was misreporting the temperature. I figured that out by moving a separate smart temperature sensor into the cool food section and monitoring it, which told me that the temperature was, in fact, just fine.

Check Your Assumptions

My problem was that instead of troubleshooting from a clean slate, I brought in a set of assumptions based on prior experience. Those assumptions are a shortcut, and in many cases that shortcut can lead to the right conclusion. But when it doesn’t, it can cost us in time or money in pursuing the wrong problem.

This can happen in the software world as well. Many developers will, over their career, work with multiple programming languages, platforms and paradigms, and the assumptions that work for one platform may not readily apply to others. So it’s really important to make sure that you’re aware of any assumptions you’re bringing to the table when you are working with a new platform (or even switching between platforms that you’re familiar with).

Know Your Defaults

One of the places this came up for me recently is during some code reviews that I’ve been participating in going over several applications built on the OutSystems low-code platform. OutSystems, like many low-code platforms, is designed to simplify and accelerate the process of creating, updating, and maintaining applications by the use of visual tools and paradigms for most of the standard programming structures, including functions and exception handling.

In OutSystems, what would typically be called a function or subroutine in a language such as C# or Java is called an Action, and is modeled as a visual flow from a start to an end node, with other nodes representing other Actions that are called, logical nodes like If, Switch, etc. Alongside the main flow, developers can also define one or more exception handling flows.

In our code reviews, Justin James, who was leading the code review, noted several instances where the exception handler logic was calling a system Action called LogMessage to log the exception information. Sounds pretty normal, right? If you’re coming from a platform like .NET, this may seem perfectly fine, because in a high-code world, you do typically have to define your logging explicitly.

OutSystems Database Exception Flow – Note the default value for Log Error is Yes

In OutSystems, however, the beginning node of an exception handler flow provides options for automatically logging the exception information, and this option is enabled by default, as shown above. So by logging the exception information explicitly in the flow, the developers were inadvertently double-logging the same information.

As Justin observed, there may well be occasions where you want to explicitly call LogMessage in order to log information above and beyond the standard exception information, but just logging the error message is redundant and provides no additional information to help troubleshoot the error. The developers were trying to do the right thing, but because they did not know the default behavior of the exception flow was to log the error, they were duplicating effort unknowingly. This is illustrated in the screenshot below:

With the default Log Error set to Yes, the Log Message node is redundant

For what it’s worth, I’ve been working with OutSystems for years, and I didn’t know that was the default behavior, so I learned something new as part of this process as well.

For those doing a lot of work on the client side, note that exceptions in Client Actions also log error information by default, though it should be noted that the specific type of exception above, the DatabaseException, does have a major difference between the Client Action and Server Action implementations in that the latter includes an option to abort the implicit transaction that is part of the default behavior for Server Actions when working with the platform database. The DatabaseException on a Client Action does not provide this option.

Challenge Yourself

So how do we avoid falling into the trap of working from assumptions that may not apply? One way is to challenge ourselves to spend time going back to basics. Whether that’s troubleshooting a problematic appliance as if it was the very first time we’re looking at it, or engaging in code reviews (formally or informally) that may help reveal things we weren’t aware of in our platform of choice, taking a step back from the day-to-day to get back into learning mode can reduce the risk of wasted time and money based on incorrect assumptions.

Do you have any favorite stories of gotchas based on incorrect assumptions or misunderstood defaults? I’d love to hear them…drop a comment below!

The Difference Community Makes

In a recent post, I talked about my background as a software developer, teacher, and developer advocate, and how I ended up finding and liking Low Code, and more specifically, the OutSystems platform. In this post, I want to talk about the importance of the software development community, and why community is one of the things that’s helped keep me in the OutSystems orbit.

Starting Fresh

Some twenty-five plus years ago, when I left behind the world of building sets, hanging lights, and long hours for little compensation of the regional theatre world, I really wasn’t sure how I was going to manage in the world of I.T. I got some good advice early on from a relative and got a few certifications, and managed to land a few jobs, first doing help desk work, and later training folks at the Pentagon in using Windows 95. Glamorous work, to be sure! I realized pretty quickly that writing software was the direction I wanted to go, but had no idea how to get there.

Enter Community

As it happens, around this time I signed up for a local event called Microsoft DevDays, which featured a series of talks by software developers from area consulting and software companies. One of these talks was given by Geoff Snowman, and he impressed me with his knowledge and presentation, so I stuck around to ask some questions, including how someone like me could get started in professional software development. A bit of conversation later, he invited me to send him a copy of my resume. A few emails, and another certification later (got my certification in Visual Basic 4, for the record), I landed my first job as a software developer.

While I’m not sure I’d classify DevDays as a pure community event, since it was organized by Microsoft, it did feature speakers from the local developer community, so I think one could call it my first exposure to that community.

My next stroke of luck was being assigned to a project with two of my new company’s top developers, one of whom was a big fan of user groups, and got me connected with the user group community in the Washington, DC area. I started regularly attending user group meetings, particularly the Internet Developer User Group and SQL Server User Group, and I learned a lot quickly as a result, and got to know a ton of great people. Eventually, I started speaking at the user groups as well, and a few short years later, I was invited to speak at the 2004 DevDays event. It was after that event that I was approached about whether I might be interested in a role at Microsoft as a Developer Evangelist.

In short, it’s not an exaggeration to say that much of my success in my career came as a direct result of finding and participating in a rich and robust developer community.

The OutSystems Community

My journey with OutSystems was in some ways a mirror of that with Microsoft in that I started in OutSystems by being hired by them, first as a Solution Architect (technical pre-sales), and later as a Developer Advocate (teaching about the platform, and sharing feedback from developers back with internal folks). In that latter position, I worked closely with the OutSystems community, particularly with the folks who were part of the MVP program.

A big strength of the OutSystems platform is the community that surrounds it. The MVPs are both advocates for the platform, but also passionate critics when there are things that they see that need improvement. Having fans who only tell you what you want to hear is not a great way to have a strong platform over time, so being able to hear feedback that the MVPs provide is really important, even if it wasn’t always comfortable on the receiving end.

The OutSystems community is also really helpful in providing support to one another through the OutSystems Forums, and in sharing reusable solutions and components in the OutSystems Forge. OutSystems helpfully provides a home page for the community at https://www.outsystems.com/community/.

OutSystems Community Home Page

On the Community page, you can find links to relevant information like the Forums, Forge, Documentation, MVP program, and events (including user groups).

I recall that at one of the first OutSystems events I attended as an employee, the NextStep conference in Boston in 2018, I was approached by Mário Araújo, who at the time was running the Developer Relations team at OutSystems, to pick my brain based on the 10 years I’d spent working with developers while at Microsoft. I liked that he (and others I’ve since worked with at OutSystems) wanted to better understand developers and how best to serve them (and how to explain to execs what developer relations is and why it’s important…such activities do require budget and buy-in, after all).

OutSystems has provided good infrastructure (Forums, Forge, several community recognition programs, etc.), and had the savvy to incentivize participation through a bit of gamification of the community sites. Community members receive points for responding to forum posts, but more points for having their answer marked as a solution, which at least in theory incentivizes quality over quantity. Points are also rewarded for publishing components to the Forge, and there are other categories as well. I would agree with those who say there’s room for improvement here, but I do think overall the gamification has strengthened the community by encouraging more consistent participation. OutSystems also has a team dedicated to supporting, understanding, and improving their platform for developers, a team I was proud to be a part of.

Find Your Community

Community has changed a lot since my early days in the developer community. What was once mostly in-person and a some online has shifted to more online with some in-person (if you’re in the OutSystems space, you can find local user groups near you on the OutSystems User Groups website), but there are still plenty of opportunities to get involved, learn more about your chosen technology, and meet folks with similar interests. Even better, you can share what you know, and help someone else who is getting started.

A developer community is a great example of a win-win for a company like OutSystems and the developers working with the platform. OutSystems gets the advantage of a group of enthusiasts sharing knowledge and helping one another be more successful with the platform, and the developer community gets the help they need, and the infrastructure to find one another, ask and answer questions, and find and share software solutions.

I have little doubt that much of the success and joy I’ve experienced in my career in software development and developer education and advocacy can be attributed to my participation in the developer community. The friends I made, the knowledge I gained, the mentorship received, all of these acted as accelerators on the path to improving as a developer and teacher.

Whether you’re an OutSystems developer, or have chosen a different software stack, I encourage you to seek out and be a part of the community for your platform. You can get help when you need it, share knowledge with others, provide feedback on the platform, and be a part of something rewarding!