Topics

Advanced

["Advanced" tag page]: Show all articles with the tag "Advanced" (including those where "Advanced" is a secondary tag).

No Longer Set: (Nov 17, 2020) The definitive guide to JetShowPlan. How to: toggle it with a keyboard shortcut, interpret its output, and add syntax highlighting to showplan.out files.

Recursion Demystified: Creating Subfolders: (Nov 29, 2020) Recursion: it's not just for calculating factorials any more! A practical example of using recursion to create multiple missing subfolders.

VBA Collections: AKA, Linked Lists: (Dec 6, 2020) Everything I still remember about the Data Structures course I took 20 years ago as it applies to Collections in VBA.

VBA Dictionaries: AKA, Hash Tables: (Dec 7, 2020) This is not an article about Amsterdam flea markets. Hash tables are the data structures upon which Dictionaries are built.

"Complex" DTOs in VBA: (Dec 14, 2020) Can you use the OpenArgs parameter to pass multiple values to forms and reports with compile-time checking? You can if you use DTOs.

Checklist: The Best Access Applications: (Dec 19, 2020) Good. Better. BEST. Is your Access application as good as it can be?

Deceptively Complex Booleans: (Dec 29, 2020) Why is VBA such an optimistic language? Because there's only one way to say "No," but 65,535 ways to say "Yes."

Super-Safe Boolean Handling: (Dec 30, 2020) If you want to be safe when working with Booleans, you need to ensure they're stored as 0 or -1. That's not as easy as you might think.

Strongly Typed Collections in VBA: (Mar 26, 2021) Get better type safety and access to IntelliSense inside For Each loops by using "strongly-typed collections" in place of the VBA Collection type.

Strongly-Typed Collections: The Easy Way: (Mar 27, 2021) Creating a strongly-typed collection class in VBA requires jumping through code export-import hoops. What if you didn't have to, though?

The Tradeoffs of ByRef and ByVal: (Apr 3, 2021) As they say, there is no free lunch. Passing by value or by reference is the sort of distinction you can mostly ignore...until one day you can't.

Raising Custom Events in VBA: (Apr 27, 2021) This quick tutorial will have you writing custom events in VBA in no time.

Using WithEvents to Encapsulate Event Handling Code: (May 4, 2021) You don't need to call the event handler for every control to handle its events. Instead, you can use WithEvents to encapsulate that code in a class module.

Handling Multiple Control Types in a WithEvents Class: (May 5, 2021) Using WithEvents to subclass form controls is a powerful technique. Here's one way to handle multiple control types in a single class.

TypeName vs. TypeOf: (May 12, 2021) You can check the type of a variable in VBA using TypeName or TypeOf. But do you know when to use which? And why? Let's explore.

VarType in VBA: (May 13, 2021) The VarType function lets you determine the underlying type of a variable. How does it fit in with TypeName and TypeOf?

Approximate String Matching Workshop: (May 19, 2021) Access wizard Alessandro Grimaldi is offering a paid workshop where he will teach how to implement the Levenshtein Distance algorithm in Access.

Double-declaring APIs: (Oct 9, 2021) Is it finally time to stop adding the `#If VBA7 Then` guard clause to PtrSafe API declarations? Let's explore.

64-bit Unsigned Integers in VBA: (Nov 22, 2021) VBA is missing a data type. The workaround--while not pretty--is at least straightforward.

Side-by-Side Installs of 32-bit and 64-bit Versions of Access: (Dec 6, 2021) You can't install two different Office bitnesses side by side on the same computer. Or can you? ...

Using Windows Authentication to Connect to SQL Server from Outside the Domain: (Dec 8, 2021) You don't need to join your computer to a domain to be able to connect to SQL Server using Windows Authentication. You just need to know this simple trick.

JetShowPlan Manager: (Dec 18, 2021) The quickest and easiest way to get started analyzing Microsoft Access query performance is with IslaDogs' JetShowPlan Manager application.

The Microsoft Access Ternary Operator: (Jan 6, 2022) It's a function. It's a statement. It's an operator. It's a--what the heck do we call this short-circuit-evaluating IIf() thing and why does it even matter?

3 Ways to Create Class Instances in VBA: (Jan 13, 2022) Before you can use a class, you need to create an instance of the class and assign it to an object variable. ... Or do you?

Mark-of-the-Web (MOTW) Details: (Mar 12, 2022) Microsoft announced that VBA will be blocked soon in all files downloaded from the web. Let's dive into how Windows manages this "Mark of the Web."

DISTINCT vs. GROUP BY: Microsoft Access Speed Test: (Mar 15, 2022) The GROUP BY and DISTINCT clauses can both be used to generate identical results. But which one is faster in Access? And--more importantly--why?

References, Protocols, and Language Specifications: (Apr 9, 2022) They're not always easy to read, but when you are looking for official answers, it's hard to beat these low-level protocol and language specifications.

HRESULT: Use "Long" and Not "LongPtr": (Aug 2, 2022) If the return type of an API function call is an HRESULT in the C++ header file, it should be declared as a Long in VBA (and not a LongPtr).

Understanding Signed and Unsigned Numbers in VBA: (Sep 9, 2022) Signed and unsigned numbers–and their hexadecimal representations–can interact in surprising ways in VBA.

Unicode Private Use Areas in VBA: (Sep 13, 2022) Looking for a safe temporary character or text delimiter that is guaranteed to not exist in your data set? Look no further than the Unicode Private Use Areas.

Announcement

["Announcement" tag page]: Show all articles with the tag "Announcement" (including those where "Announcement" is a secondary tag).

Combo Boxapalooza!: (Jun 4, 2021) Join me at 9 AM EDT on Friday, June 18th, where I'll help you unlock the true potential of my favorite Access control: the combo box.

Are You an Access Developer in Northeast Pennsylvania?: (Oct 25, 2021) Calling all (current or aspiring) Access developers in Northeast PA: we have an immediate job opening at Grandjean & Braverman, Inc.

Microsoft Access MVP: (Nov 1, 2021) Say hello to the newest Microsoft MVP Awardee for Office Apps & Services (MS Access).

Access Roadmap Update: (Nov 15, 2021) Microsoft has recently updated the Access roadmap for 2021 and beyond. Check out what's on the horizon for the next 14 months.

Access Dataverse Connector Presentations: (Dec 1, 2021) A list of past and upcoming presentations on the Access Dataverse connector with Access Program Manager Michael Aldridge.

Access NewsCast with Karl Donaubauer: Episode 1: (Dec 15, 2021) The very first edition of Access News with Karl Donaubauer was released today. Catch up on the latest news and updates in this 30-minute video.

Upcoming Presentation: Troubleshooting Query Performance: (Feb 9, 2022) Join me online on Thursday, March 17, for my presentation, "Troubleshooting Query Performance," to the Denver Area Access User Group.

Office to Disable All VBA Code in Files from the Internet: (Feb 12, 2022) Beginning in April 2022, users will no longer have the option to manually enable VBA code in Office files downloaded from the internet.

Access DevCon Vienna 2022: (Mar 9, 2022) Mark your calendars and register for Access DevCon Vienna! The event will be held virtually via MS Teams on April 28 and 29, 2022, from 10 AM - 4 PM EDT.

Access NewsCast with Karl Donaubauer: Episode 2: (Mar 21, 2022) Catch up on the latest news and updates from the Access world in episode 2 of Karl's webcast, featuring Thomas Pfoch's Access map tool.

IE11 Retirement FAQ for Access Apps: (Apr 2, 2022) Internet Explorer 11 will reach end-of-life before we have an Edge-based browser control. Read on to learn how this will affect Access developers.

twinBASIC DevCon Vienna: Volume 2: (Apr 4, 2022) It's back! This year's Access DevCon Vienna will feature twinBASIC for the second year in a row. This time around the focus is on practical uses for Access developers.

Building Ribbon Interfaces in Code: (May 26, 2022) Join me online on Wednesday, July 6, for my presentation "Building Ribbon Interfaces in Code" to the Access Europe user group.

What Happened to the Access Roadmap: (May 31, 2022) Don't be (too) alarmed about the lack of feature development shown on the Access public roadmap. Access isn't dead...you just need to know where to look.

Access at Microsoft Build 2022: (Jun 14, 2022) You'll never guess what the Access team talked about at the recent annual Microsoft Build conference. I'll give you a hint: it rhymes with "beta curse."

Office Apps Won't Run on Windows Server After October 2025: (Jun 30, 2022) Earlier this month, Microsoft quietly announced the end of support for running (most) Office apps on Windows Server at the end of 2025.

Microsoft Backtracks (Temporarily?) on Policy to Block All Macros with Mark of the Web: (Jul 7, 2022) Microsoft official announces in blog comments (!) that they are rolling back their recently implemented VBA-blocking policy.

vbWatchdog v4 Released: (Jul 29, 2022) Version 4 of vbWatchdog just got released. If you don't already own a license for it, you should. And if you do, you should upgrade before August 31, 2022.

Timeline for VBA Macros Blocked by Default in Microsoft Office: (Sep 26, 2022) Enterprise customers are next in line to have macros blocked by default in Office files from the web. The policy addresses a real problem, but does it actually help?

Access NewsCast with Karl Donaubauer: Episode 4: (Oct 7, 2022) Catch up on the latest news and updates from the Access world in episode 4 of Karl's webcast, with guests Colin Riddington, Wayne Phillips, and, of course, Viktoria.

Prepare for the Upcoming Death of IE11: (Oct 28, 2022) The grim reaper takes IE11 for good on February 14, 2023. Prepare for the inevitable now to avoid unnecessary Valentine's Day pain.

API

["API" tag page]: Show all articles with the tag "API" (including those where "API" is a secondary tag).

AutoHotKey

["AutoHotKey" tag page]: Show all articles with the tag "AutoHotKey" (including those where "AutoHotKey" is a secondary tag).

Debugging VBA with no Break Key: (Oct 27, 2020) Ever use a keyboard without a Pause/Break key? It's no big deal for most people, but if you develop in VBA it's a huge deal.

A Mind-Reading Script: (Oct 28, 2020) What if you could highlight any text, press a hotkey, and have Windows do what you want almost every time? You'd have my top productivity hack.

Expand Your Access Palette: (Oct 31, 2020) Use AutoHotkey to bring consistency to your Access color schemes and save time when designing forms.

Size Matters: (Nov 1, 2020) Testing your program for small screens? You could change your own monitor's resolution, but that gets annoying real fast. Here's a better way.

"Toggle" Hotkey for the Immediate Window: (Nov 18, 2020) Am I the only one who finds it annoying that [Ctl] + [G] doesn't *toggle* between the immediate window and the code window? Let's fix that.

Streamlining SaveAsText / LoadFromText: (Mar 19, 2021) SaveAsText and LoadFromText are indispensable for Access version control. They're also annoying to type repeatedly. Let's fix that.

Toggle ODBC TraceSQLMode with an AutoHotKey Script: (Mar 14, 2022) Traditional methods of enabling and disabling ODBC TraceSQLMode are a pain in the neck. This AutoHotKey script makes it as easy as pushing a button.

Backwards Compatibility

["Backwards Compatibility" tag page]: Show all articles with the tag "Backwards Compatibility" (including those where "Backwards Compatibility" is a secondary tag).

Adding Procedure Parameters Without Breaking Backwards Compatibility in VBA: (Nov 22, 2022) Sometimes you need to add a parameter to a Function or Sub in VBA. But you don't need to break all of your calling code to do it.

Basic

["Basic" tag page]: Show all articles with the tag "Basic" (including those where "Basic" is a secondary tag).

It Takes Two: (Sep 5, 2020) Microsoft Access is both a rapid application development (RAD) environment and a file-based database system. It is actually quite capable in each area. But they are two fundamentally different functions.

One if ByRef, and Two if ByVal: (Sep 19, 2020) Arguments in VBA are passed by reference by default. What does that mean? And what are the differences between passing by reference and by value?

VBA and Unicode: (Dec 6, 2020) VBA and Unicode go together like Bailey's and Lime. But pretending the problem doesn't exist won't make it go away. Even for us Americans.

Checklist: Is Your Access App GOOD?: (Dec 17, 2020) GOOD. Better. Best. Does your Access application clear the lowest bar for quality?

Unicode-Friendly MsgBox: (Dec 24, 2020) There's a great big world outside of the ANSI bubble. Make every MsgBox in your program Unicode-safe in no time at all with this drop-in replacement.

Constructing Version Numbers: (Jan 8, 2021) Every program needs a version number. But there's no need to overthink it. When versioning Access apps, less is more.

Pseudocode Programming Practice: (Jan 23, 2021) Is it bad practice to write comments first and then code? Not at all. In fact, it's one of the most powerful techniques in building good code.

Proper Use of Global State: (Jan 24, 2021) With great power comes great responsibility. Use global variables wisely.

The Global Form: (Jan 25, 2021) Storing global variables on a hidden form has some distinct advantages over storing them in VBA.

The Danger of Do Loops: (Feb 26, 2021) If you're going to write a Do Loop, don't forget to update whatever it is you're using to break out of said loop. And, oh yeah, save before testing!

The Extra Resume: (Feb 27, 2021) Want an easy way to jump to the line that raised the error AND avoid the infinite loop time bomb? Add an extra Resume.

Watching and Waiting: (Mar 5, 2021) Careful what you watch for! Monitoring changes to a slow expression can grind your debug session to a halt.

Looping Through a List of Items: (Apr 2, 2021) Here's a quick and dirty way to loop through a list of items in VBA.

DRY: Don't Repeat Yourself in VBA: (Apr 25, 2021) A journey from basic to advanced, covering functions, subroutines, user defined types, class modules, WithEvents, interfaces, and even code generation.

Event-Driven Programming in VBA: (Apr 26, 2021) Event-driven programming may sound complicated, but the concept is really quite simple.

Navigating Continuous Forms: (Apr 28, 2021) If Up is left and Down is right, you must be navigating a continuous form in Microsoft Access.

Handling Keyboard Events in Access: (Apr 29, 2021) This beginner article will step you through the process of how to begin writing code that runs when a user presses a key on the keyboard.

KeyCode and Shift Arguments: (Apr 30, 2021) The KeyDown and KeyUp events include KeyCode and Shift arguments to identify which keys the user pressed. Let's explore those arguments in more detail.

Field Comments on Linked Access Tables: (May 25, 2021) In part 1 of this series on field comments, we discuss maintaining column descriptions on tables linked to MS Access back-end files.

Easy Access to Field Descriptions: (May 29, 2021) The ExtractFieldComments() function returns a dictionary of field names and their descriptions from a TableDef object.

Field Comments on Linked Tables: (Jun 2, 2021) In this 6-part series, I cover everything you need to know about field descriptions for linked tables with Access and SQL Server back-end databases.

Combo Box: Behavior Deep Dive: (Jun 5, 2021) Join me as I take you on an animated gif guided tour of the default behavior of the Microsoft Access combo box, with emphasis on the autocomplete feature.

Anatomy of a CRUD App: (Jun 30, 2021) Microsoft Access is a great platform for developing desktop CRUD apps. But what the heck is a CRUD app?

Split Your Microsoft Access Applications...Or Else: (Jul 13, 2021) "Ghostbusters" has some important lessons to teach us about Access application development.

Poor Man's Status Bar in VBA: (Jul 24, 2021) If you're looking for a quick and dirty way to keep track of a long-running process while developing, this VBA one-liner will do the trick.

Avoid DoCmd.RunSQL in Microsoft Access: (Aug 3, 2021) If you are just starting out writing VBA in Microsoft Access, you may be tempted to use DoCmd.RunSQL. Don't. There is a better way.

How to Pause Your VBA Code For a Set Amount of Time: (Aug 9, 2021) There is no built-in function to pause code in VBA. The easiest and safest way to do it is to use the Sleep API function. Here's a quick how-to.

What the Vancouver Stock Exchange Can Teach Us About Rounding Numbers in VBA: (Aug 18, 2021) So you think you know how to round decimals. Do you, though? There may be more to it than you think.

How to Customize the Access Ribbon on a Developer Machine: (Sep 2, 2021) This step-by-step guide shows you how to customize the Microsoft Access ribbon and add missing commands.

The Difference Between Good and Bad Code Comments: (Oct 8, 2021) The difference between good and bad comments explained in under 25 words.

Beware the BETWEEN: (Oct 13, 2021) Using the BETWEEN clause with date-time fields may lead to unexpected results. There's a safer alternative.

The QBE Window: Training Wheels for Access Developers: (Oct 15, 2021) If you're new to relational databases, the QBE window is the solution to--and cause of--many of your query problems.

How to Loop Through a List of Strings in VBA: (Dec 16, 2021) Looking for a quick and simple way to loop through a list of strings? These 4 lines of code are all you need.

How to Pause VBA Code: (Jan 14, 2022) A simple Windows API call makes for a reliable and efficient way to pause your VBA code. Much better than a "do-nothing loop."

Microsoft Access Acronyms: (Jan 28, 2022) Bookmark this handy reference so the next time you come across an Access acronym that you don't recognize, you will have a quick way to look it up.

The Strange Behavior of Null: (Mar 18, 2022) When are two identical values not equal? When they're both Null! If you are a Microsoft Access developer, you need to understand how (and why) this works.

Learn VBA From a Master: (Apr 8, 2022) Philipp Stiefel is on a very short list of people who I would pay to teach my employees how to write VBA.

The Single Most Important Concept for Understanding Relational Databases: (Dec 27, 2022) If you're coming to the database world from the spreadsheet world, this one key concept will help you make the necessary mindset shift.

All About Indenting: (Jan 10, 2023) Do you obsess over the smallest details of the code-writing process? If not, you might want to skip this article. Don't say I didn't warn you...

Subs vs. Functions in VBA: (Feb 7, 2023) What is the difference between a Sub and a Function and why would you use one or the other? I'll give you the short answer...and then we can explore the long answer.

Best Of

["Best Of" tag page]: Show all articles with the tag "Best Of" (including those where "Best Of" is a secondary tag).

My Top 10 Allen Browne Posts: (Nov 11, 2022) If you're a Microsoft Access developer and you've never heard of Allen Browne, then you are in for a treat...

Bug Alert

["Bug Alert" tag page]: Show all articles with the tag "Bug Alert" (including those where "Bug Alert" is a secondary tag).

MS Access Report Horizontal Scroll Bar Bug: (Apr 1, 2021) When certain reports open, the horizontal scroll bar gets drawn on the screen and then gets stuck in its original draw location.

Bug Alert: vbWatchdog: (May 31, 2021) How to fix the E_VBWATCHDOG_UNSUPPORTED_VBAVERSION error.

Bug Alert: Malwarebytes: (Sep 25, 2021) New behavior-matching algorithms in Malwarebytes block execution of Access applications that call out to the Shell function.

Compact on Close Danger: (Oct 21, 2021) Compact on Close. It seems innocent enough. But lurking under this seeming convenience is the spectre of corruption just lying in wait.

Access Bug Alert: Errors When Opening Network Database Files: (Dec 17, 2021) If you started receiving the error "File in use" or "Could not lock file" in December 2021, you may be the victim of an Access bug. Here's how to fix it.

Partial Workaround for the "Could not lock file" Bug: (Dec 28, 2021) This experimental function could help you avoid the "Could not lock file" error when running the OpenDatabase method of a DBEngine object.

Patching Access 2013 Runtime to Fix "File Already In Use" Bug: (Jan 8, 2022) Step-by-step process to patch the 2021 Holiday Bug for Office/Access 2013. These same steps can be adapted to patch other versions, too.

Bug Alert: Can't Access Shared Folders via UNC Alias: (Jan 18, 2022) UNC aliases are a great way to set up development environments for Access applications that rely on UNC paths. It's too bad Microsoft broke them.

Bug Alert: Cannot Open Any More Tables/Databases: (Feb 5, 2022) Check out the latest bug release from Microsoft: "Cannot open any more tables/databases.", .laccdb file remains, msaccess.exe hangs, and more...

BUG ALERT: No Current Record: (May 11, 2022) An Access bug introduced in the latest Patch Tuesday update caused major headaches for developers around the world today.

Office FeatureGates: How Microsoft Can Break and Fix Their Applications in Under 24 Hours: (May 30, 2022) Microsoft Access regularly breaks following Office updates. But, sometimes, it *starts* working again just as suddenly. Here's how that works.

WARNING: Do NOT Declare DAO Fields As Field2, Field3, etc.: (Jul 13, 2022) While declaring DAO Field objects as Field2 will get you additional IntelliSense, it comes at the risk of breaking working code when MS releases a new Field type.

Bug Alert: Wizards Don't Work with MVFs and Attachment Fields: (Aug 22, 2022) Beginning with version 2006, Access hangs when running the Report or Labels Wizard on a table with a multi-valued field (MVF) or attachment field.

BUG ALERT: CurrentDb and DAO.OpenDatabase: (Oct 6, 2022) If you are getting intermittent error messages saying you don't have exclusive access to your database, then this workaround may help.

Bug Alert Follow-Up: CurrentDb and DAO.OpenDatabase: (Oct 10, 2022) A member of the Microsoft Access engineering team provides an official explanation for the "buggy" CurrentDb and DAO.OpenDatabase behavior.

BUG ALERT: FortiClient VPN and Windows Update KB5018410: (Oct 13, 2022) A recent Windows Update broke my FortiClient VPN. Learn which update was responsible, how to uninstall it, *and* how to keep it from coming back.

Bug Types

["Bug Types" tag page]: Show all articles with the tag "Bug Types" (including those where "Bug Types" is a secondary tag).

Syntax Errors: (Aug 5, 2021) Every programming language has its own syntactical quirks. The C family loves braces. Python loves indentation. BASIC loves words. And Perl loves #%@!{}]&.

Compile Errors: (Aug 6, 2021) Compile errors are easy to keep out of deployed code (just remember to Debug > Compile). Which is good because they hard crash Access in Runtime mode.

Misunderstood Requirements in the Project Design Phase: (Aug 7, 2021) Your client knows what's wrong. They *think* they know how to fix it. But treating symptoms is never as effective as treating the disease.

Automated Test Errors (aka, Failing Tests): (Aug 10, 2021) You can have a bug in your code and/or in your test. You're unlikely to have the *same* bug in your code and your test.

Logic Errors: (Aug 19, 2021) The logic error is the most dangerous and insidious of all software errors.

Runtime Errors: (Aug 20, 2021) It's impossible to predict every possible scenario that could befall our applications in the wild. But we need to at least try.

Misunderstood Requirements (After You've Written the Code): (Aug 21, 2021) As you install the final piece of crown molding in the dog's second bedroom, you can't help but smile at the absurdity of it all.

"It Runs On My Computer": (Aug 28, 2021) Here are the 7 most common reasons I've had to utter those words as an Access developer.

Business

["Business" tag page]: Show all articles with the tag "Business" (including those where "Business" is a secondary tag).

My Personal Journey: (Jan 5, 2021) Join me on a self-indulgent trip down memory lane, rationalized as a "context-setting" exercise for future business-focused articles.

My Biggest Business Mistake: (Jan 6, 2021) What's the best way to bill for ongoing technical support? I don't really know (HA!). But I think I know the worst way to do it.

Pricing Annual Technical Support: (Jan 7, 2021) How am I trying to fix my biggest business mistake? By giving my clients three options that explicitly address their risk tolerance.

Google Analytics Alternatives: (Jan 11, 2021) Avoid GDPR cookie-consent forms and respect your website users' privacy with one of these privacy-friendly Google Analytics alternatives.

Site Search for NoLongerSet!: (Apr 5, 2021) It was long past time I added sitewide search to this Ghost-powered blog. I could have used Solr, ElasticSearch, or Google. I chose something else...

The Biggest Mistake Access Developers Make When Writing a Custom Software Proposal: (Jun 19, 2021) I made this mistake myself for years. The good news is it is very easy to fix!

The Most Profitable Mindset Shift for Access Consultants: (Jun 22, 2021) What do you call it when a client uses emotional language on multiple occasions to describe the same problem? A business opportunity.

How Access Developers Can Charge Their Existing Clients More (Without Feeling Guilty): (Jun 23, 2021) When you offer only a single option, a proposal is an ultimatum. Add in some monopoly power, and that proposal can start to feel like extortion.

Prices vs. Estimates (And How to Educate Your Clients on the Difference): (Jun 25, 2021) A price is a fixed amount. An estimate is just a guess. But try telling that to an angry client at the end of an over-budget project. There's a better way.

Manage Email Addresses for Multiple Domains with One Gmail Account Using Opalstack: (Oct 11, 2021) Some practical advice on how to configure email addresses for multiple domains so that you can still send and receive from a single Gmail account.

Configuring a Send-Only Email Address in Outlook 2019: (Oct 13, 2021) How to add an account in Outlook 2019 where the user name is NOT the same as the email address.

The Hour-Tracking Journey: (Oct 22, 2021) From Palm Pilots to Google Sheets to Clockify, I take a trip down hour-tracking memory lane.

Level Billing: A More Predictable Way to Bill Hourly: (Nov 2, 2021) If you bill by the hour, you probably have clients with whiplash as their invoices yo-yo from month to month. Provide them predictability with level billing.

Comparative Advantage: (Nov 8, 2021) One person can be more productive than another in every way, and yet, by trading freely with each other, both sides can come out ahead.

Shared Reports in Clockify: (Nov 18, 2021) Never waste time preparing a detailed list of hours for your clients again using this handy feature from Clockify.

The Most Important Rule in Client Contracts: (Aug 3, 2022) This rule can be the difference between project success and project failure; joy and misery; profit and loss.

Sole Proprietorship vs. Partnership vs. LLC vs. S Corp. vs. C Corp.: (Aug 4, 2022) What's the best type of business for you? It depends on where you're at on your journey.

ChatGPT

["ChatGPT" tag page]: Show all articles with the tag "ChatGPT" (including those where "ChatGPT" is a secondary tag).

Copyright Implications of ChatGPT Content: (Jan 3, 2023) ChatGPT from OpenAI is taking the world by storm. Who owns the ChatGPT output? Can you pass it off as your own? Do you need to acknowledge OpenAI?

ChatGPT: (Jan 4, 2023) The personal computer. Google search. The smart phone. Lifelike chat bots. Another generation-defining technology has arrived.

My Policy on ChatGPT-Generated Content: (Jan 5, 2023) I plan to use ChatGPT to generate content at NoLongerSet.com. But I plan to do it with full transparency. Here is my pledge to you, dear reader.

Class Modules

["Class Modules" tag page]: Show all articles with the tag "Class Modules" (including those where "Class Modules" is a secondary tag).

Caching Object Instances in VBA Classes: (Feb 7, 2022) Simplify the object initialization code in your class modules without sacrificing performance using this easy technique.

Great Intro to Class Programming in VBA: (Apr 5, 2022) Former Access MVP Ben Clothier's primer on class programming in VBA should be required reading for all Access developers.

Code Library

["Code Library" tag page]: Show all articles with the tag "Code Library" (including those where "Code Library" is a secondary tag).

Quoth thy SQL? Evermore!: (Sep 29, 2020) Solving the "O'Malley problem" with dedicated functions to sanitize our strings. Little Bobby Tables would be proud.

Come Together: (Sep 30, 2020) Do you build strings in loops? Stop trimming the delimiter at the end of the loop. There's a better way.

One Thing at a (Hundred) Times: (Oct 7, 2020) How to use Run() and GetTickCount() for some quick and dirty performance profiling. Come for the code, stay for the scolding on premature optimization.

The Dependency Train: (Oct 17, 2020) Let's torture a train metaphor to illustrate the dangers of dependency chaining.

Creating Optional Dependencies: (Oct 18, 2020) Using conditional compilation to avoid the "Dependency Train" problem.

Code Library Updates: (Oct 29, 2020) Q: How do you manage updates to code library modules? A: Version control and backward compatibility zealotry.

My Dirty Little Secret: (Nov 2, 2020) I don't use Me.Dirty = False in my #msaccess code. I wrap it up and call it from a "guard clause" instead.

Filling in the Blanks: (Nov 3, 2020) One of the keys to being a good developer is to make the *easy way* also be the *right way*. Exhibit A: the ControlIsBlank() function.

Why so lazy, Access?: (Nov 4, 2020) Introducing FormIsOpen() and ReportIsOpen(), two simple functions to help deal with Access's laziness.

Environmentally Friendly Access: (Nov 5, 2020) Using the Windows Registry to manage Production, Development, and Testing environments in #VBA and #MSAccess.

Don't Settle for the "Status" Quo: (Nov 6, 2020) Wherein I wrap Access's built-in status bar functions inside a class module for more readable code.

Part and Parse()-l: (Nov 8, 2020) Take the Tag property and OpenArgs argument to the next level. This function makes it easy to assign and extract multiple values from a single string.

Listing External Table Sources: (Nov 9, 2020) Using the Parse() function to list linked tables by source. Use this when you want to refer to Linked Table Manager info while writing code.

Now you have two problems: (Nov 16, 2020) Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems. --Jamie Zawinski

"Convenience" Date Functions: (Nov 24, 2020) The DateSerial function is easy to write, but it's not as easy to read. Let's make our code easier to read with some "convenience functions."

Fun with Form Windows: (Nov 26, 2020) Using my FillAccessWindow function to resize Form and Report objects relative to the amount of available space on the Access canvas.

Get Back Here, Form!: (Nov 27, 2020) What happens if the user resizes their Access window so that our form can't open in its entirety? KeepFormOnCanvas() to the rescue!

Converting Numbers to Text: (Nov 28, 2020) Need to print business checks directly from Microsoft Access? You'll need a way to convert numbers into text. The NumToString function does just that.

The Subtle Dangers of Dir(): (Dec 1, 2020) If Len(Dir(FullPath)) > 0 Then 'the file exists. This potential bug patiently waits to pounce and ruin another poor programmer's day.

Kill Failed? Let User Try Again: (Dec 2, 2020) My Access applications regularly need to overwrite existing files. A common example is exporting data to a text file, such as a .csv. Sometimes the user chooses to overwrite the existing file, and sometimes the program is hard-coded to save to a specific filename. Oftentimes, the user wants to immediately

Text Files: Read, Write, Append: (Dec 4, 2020) There is beauty in simplicity. These three functions for reading, writing, and appending text files are simple, but effective.

Writing Code with Code in VBA: (Dec 10, 2020) Can you write code with code in VBA? Yes. Should you write code wit--OH, BE QUIET YOU!!! Where's your sense of adventure? ;-)

Clearing a List Box in Access: (Dec 21, 2020) Sometimes you need to wipe the slate clean and start fresh. Here's a simple function to do just that for an Access list box.

Unicode-Safe Filtered Filename Lookups: (Dec 23, 2020) Need a Unicode-safe way to retrieve a list of filenames from a folder? And its subfolders? And filtered by filename? It's all here!

Get a Handle on Window State: (Dec 28, 2020) Using the IsZoomed and IsIconic API calls to return the window state (minimized, maximized, or restored) of a form, report, or Access itself.

Setting MultiSelect At Runtime: (Jan 14, 2021) You can't actually set a list box's MultiSelect property at runtime. But there are a few ways to work around the limitation. Let's explore them.

Federal Holidays in VBA: (Feb 1, 2021) How do you calculate US federal holiday observances in VBA? One option is to use brute force and skip the calculation altogether.

VBA IsBusinessDay() Function: (Feb 2, 2021) A simple function that returns True except for weekends and US federal holidays.

IsLastBusinessDayOfMonth() Function: (Feb 3, 2021) I bet you can't guess what this function does.

Counting Weekdays in VBA: (Feb 4, 2021) This otherwise mundane function is made a bit more interesting through its use of the little-known VBA backslash operator, which performs integer division.

Counting Business Days in VBA: (Feb 5, 2021) Counting business days is easy with the WeekDayCount() and FedHolidays() functions. What's interesting is how we test the WorkingDayCount() function.

Using TDD to Calculate Holidays in VBA: (Feb 6, 2021) This article takes you step-by-step through the Test Driven Design process, unencumbered by the complexity of any sort of testing framework.

Joining Paths in VBA: (Feb 11, 2021) How many times have you gotten a runtime error because you had duplicate or missing backslashes in your file paths? Never again!

RegOp Class for 64-bit VBA: (Feb 17, 2021) Updating a classic VBA registry reading and writing class module for 64-bit compatibility.

RegOp Quick Tip: (Feb 18, 2021) Be respectful of your user's registry. Store all your applications' settings in a dedicated publisher subkey.

Sticky Wicket: Looping by Month: (Feb 20, 2021) Some programming problems are difficult to solve. Others are difficult to solve clearly.

Looping by Month: DateSerial: (Feb 21, 2021) The first approach to looping by month uses only the builtin VBA functions DateSerial() and DateDiff().

Looping by Month: Custom Functions: (Feb 22, 2021) By using a couple of custom functions, we can write very readable loops that iterate one month at a time.

Creating a Monthly Lookup Table: (Feb 23, 2021) Having a table where each record represents a single month can come in quite handy. Let's create such a table.

Looping by Month: Lookup Table: (Feb 24, 2021) Have I ever used this method? No. Can I imagine a situation where it could be useful? Maybe. Should I write an article about it? Sure, why not.

Looping by Month: Loop Until with DateAdd: (Feb 25, 2021) Reader Francesco Foti writes in with his own solution to the Looping by Month challenge.

How to Set a Breakpoint Inside of an Access Query: (Mar 4, 2021) Did you ever want to set a breakpoint inside of an executing query? How about inside a form event property? This trick lets you do it.

Nothing To See Here: (Mar 22, 2021) Introducing InformNoData(), a simple function to improve the user experience when there is no report data to show.

Finding the Temporary Folder with VBA: (Mar 23, 2021) Be a good steward of your users' file system. If you are creating temporary files, be sure to create them in the designated temporary folder.

Getting a Temporary File Name with VBA: (Mar 24, 2021) Here is a simple function to generate an unused temporary file name in VBA.

Get Form By Control: (May 14, 2021) A VBA function that returns the first form parent of the control you pass to it.

Microsoft Access: Check if Form Object is a Subform: (May 15, 2021) How do you check if the form object is a subform in Access without triggering a runtime error? Hint: this is a trick question.

Get Top Form By Control: (May 17, 2021) A VBA function that returns the topmost form parent of any control you pass to it.

weArrowKeyNav Class: (May 18, 2021) Do you want the up and down arrow keys to move to the previous and next records in a continuous Access form? Here's how to do that with only two lines of code.

The One Function Every VBA Developer Needs in a WithEvents Class: (Jun 15, 2021) Your WithEvents event handlers will only run if you set the event property to "[Event Procedure]." Here's a safe and easy way to do that.

How to Highlight the Current Record in a Continuous Form: (Jul 2, 2021) Step-by-step instructions for applying a custom highlight to the currently selected record in a continuous form in Microsoft Access.

Fix for the error: "You can't hide a control that has the focus" in Microsoft Access: (Jul 7, 2021) The DefocusIfActive() procedure shifts the focus away from a control so that it may be hidden or disabled.

How to Safely Hide Controls in Microsoft Access: (Jul 10, 2021) I *never* set the Visible property of a form control directly. Instead, I use a convenience function so that I don't have to worry about run-time error 2165.

Quickly List the Properties of an Object in Access: (Aug 23, 2021) Here's a quick and dirty procedure to iterate through an Access object's Properties collection.

Converting the DataTypeEnum Values to Equivalent VBA Types: (Oct 5, 2021) Two simple functions to convert DataTypeEnum values to descriptive strings and their VBA data type counterparts.

Preventing File-Writing Race Conditions in VBA: (Dec 7, 2021) If you're waiting on an external process to write a file to disk, how can you be sure it's really done? This routine helps avoid (or at least rule out) some race conditions in VBA.

A Safer Alternative to BETWEEN When Filtering Dates: (Dec 11, 2021) This convenient function generates defensive SQL statements to help you avoid the subtle dangers of the BETWEEN statement when filtering dates.

A Function to Quote Literal Dates When Building SQL in VBA: (Dec 13, 2021) This improved version of my date-quoting convenience function eliminates a common source of date-handling ambiguity via the ISO date format.

How to Check if VBA is Running in 64-bit Mode: (Dec 20, 2021) A simple function (or class property) that returns whether the VBA code is running under 32-bit mode or 64-bit mode.

Automatically Cleaning Up Temporary Files on Program Exit: (Dec 22, 2021) A dead-simple way to clean up temporary files without having to worry about waiting until they are no longer in use.

How to Remove Special Characters from a VBA String: (Dec 23, 2021) A simple function to remove special characters from a string in VBA. Useful for sanitizing file names, sheet names in Excel, and lots of other stuff.

Convert CIDR Notation to IP Address Range in VBA: (Jan 22, 2022) A VBA function to convert from CIDR notation (192.168.1.1/24) to the corresponding IP range (192.168.1.0 - 192.168.1.255).

How to Return the Precision and Scale of a Decimal Field in Access: (Feb 22, 2022) There's no way to use DAO to return the scale and precision of a Decimal field in Access. Luckily, there's an easy workaround using ADO.

How to Check If Two Variant Values Are Equal (or Not) in VBA: (Mar 19, 2022) While tempting, you can't simply use the equality (=) or inequality (<>) operators to compare Variant values in VBA. Here's a safer alternative.

The Pluralize Function: (Apr 1, 2022) You don't have to settle for messages like, "1 record(s) inserted." This simple function is an easy way to format strings for pluralization in VBA.

Displaying Human Readable Time Spans: (Apr 13, 2022) The HumanizedSeconds() and ConvertToSeconds() functions work hand-in-hand to provide a general solution for storage and display of time spans.

Displaying Very Long Human Readable Time Spans: (Apr 14, 2022) With 29-million-year time spans, you can handle almost any task (besides evolution, continental drift, and adding the LAA flag to MS Access).

Printf Function: (Apr 19, 2022) User @wqweto's string interpolation VBA function has some neat tricks, like using Unicode's Private Use Area to get safe temporary placeholder characters.

Show a Friendly Message When a Report Has No Data: (May 10, 2022) A handy function you can call from an Access report's Property Sheet to gracefully inform the user when their report has no data to display.

SQL Server "Codify" Function: (May 20, 2022) This function will jump-start the process of converting long descriptions into meaningful abbreviations. It's great for creating "Code" columns in lookup tables.

TagWrap() Function: (Jun 20, 2022) This convenience function helps you write more readable code when building strings with HTML-style opening and closing tags.

XmlWrap() Function: (Jun 21, 2022) This convenience function helps you write more readable code when building Office Ribbon-flavored XML strings.

GetAttr(): Ribbon XML String-Building Helper Function: (Jun 24, 2022) When you're building strings in code with lots of optional values--such as ribbon XML attributes--this simple function helps keep your code readable.

Set Report Properties in Bulk: (Jun 27, 2022) Looking to set a report property, such as an event handler, to the same value for multiple reports? Use this routine to automate the whole process.

LogToTempFile() Function: (Jul 4, 2022) A quick and dirty method for debugging large strings in VBA.

clsApp: My Application-Wide MS Access Singleton Class Module: (Jul 11, 2022) I use many class modules in my applications, but this is the one I cannot live without.

3 Ways to Get and Set the TitleBar Text for an MS Access Application: (Jul 12, 2022) Here are three ways to set the Application Title for an MS Access application. My preferred method allows getting and setting with a single line of code.

SelectedListBoxItems() Function: (Jul 14, 2022) It's not difficult to get the selected items from a multi-select list box, but it is tedious. This function makes it simple and easy.

IMPROVED: SelectedListBoxItems() Function: (Jul 15, 2022) A clearer and (very slightly) more performant version of my SelectedListBoxItems function.

CreateGuid: A Reliable Way to Generate GUIDs in VBA: (Aug 5, 2022) A well-tested method to generate GUIDs in both 32-bit and 64-bit VBA.

GetTempPath: Using the Windows API for Maximum Performance: (Aug 8, 2022) If you are looking to maximize performance in VBA, using the Windows API will almost always be your best bet.

LimitTextLength: Enforce Max Text Length for Unbound Text Boxes and Combo Boxes: (Aug 10, 2022) A handy function to enforce maximum string lengths for unbound text boxes and combo boxes in Microsoft Access.

MakeSurePathExists: Using the Windows API to Create Missing Subfolders in VBA: (Aug 12, 2022) A Windows API function makes verifying (and creating, if necessary) a full folder hierarchy dead simple.

EnsurePathExists: A Unicode-Safe Way to Create Missing Subfolders in VBA: (Aug 15, 2022) The EnsurePathExists function--based on the API function SHCreateDirectoryExW--is the ultimate tool for verifying and creating folder structures.

3 Ways to Create Missing Subfolders in VBA: (Aug 16, 2022) If you need to generate multiple levels of subfolders using VBA, these three functions will each get the job done.

UseHand(): Changing the Mouse Cursor in Microsoft Access: (Aug 31, 2022) A classic Microsoft Access mouse cursor trick gets simplified and updated for 64-bit VBA compatibility.

NewSort(): Sort a Continuous Form by Clicking on the Column Label: (Sep 1, 2022) Sort a continuous form in MS Access by simply pointing at a column label. These functions make it easy.

ObscureInfo(): Hide Sensitive Information in Access Form Controls: (Sep 7, 2022) Avoid over-the-shoulder attacks and prevent accidental disclosures in your Microsoft Access forms with this easy-to-implement function.

Getting the Temp Folder in VBA: (Sep 30, 2022) There are many ways to get the temporary folder in VBA. But if you look behind the curtain, there's really only one...

A GUID-Based Temporary File Name Generator: (Oct 3, 2022) If you need a reliable and fast way to create lots of temporary file paths, a GUID-based filename generator has some compelling benefits.

SetPredeclaredId(): Change the Hidden PredeclaredId Attribute of a VBA Class Module: (Oct 5, 2022) This simple function overcomes the lack of a hidden attribute editor for PredeclaredId values in the VBA development environment.

WriteTempFile(): A Simple VBA Function to Save Text to a New Temporary File: (Oct 11, 2022) If you need to save a string to a temporary file in VBA, this simple function will do the trick.

Writing Boilerplate Code by Hand is for Suckers: (Oct 17, 2022) Writing repetitive code may be a necessary evil in VBA, but it's a lot less tedious if you generate most of it in VBA itself.

Create a Class Module from a String in Microsoft Access: (Oct 18, 2022) Generate VBA class modules from strings during design time using this simple function in Microsoft Access.

GetLatestOdbcDriver(): Use VBA to get the Latest SQL Server ODBC Driver: (Dec 12, 2022) This simple VBA function will check the user's registry and return the latest ODBC driver from a list of supported drivers that you can customize.

GetLatestOledbProvider(): Use VBA to get the Latest SQL Server OLE DB Provider: (Dec 14, 2022) This simple VBA function will check the user's registry and return the latest OLE DB provider from a list of supported providers that you can customize.

Dt() Function v2: Handling Time-Only Date Values: (Dec 19, 2022) An important bug fix for my previously published date-wrapping VBA function that addresses an issue integrating time-only values with SQL Server.

Dt() Function v3: Refactoring with Automated Tests: (Dec 20, 2022) Reader Brenda Bachtold provides a more readable version of my date-wrapping function. Automated doc tests prove that her version functions the same as mine.

Converting VBA Long Color Values to RGB: (Dec 29, 2022) The VBA RGB() function converts red, green, and blue values into a VBA long integer color value. This simple function works in the other direction.

COM

["COM" tag page]: Show all articles with the tag "COM" (including those where "COM" is a secondary tag).

What the #$%& is COM!?: (Nov 19, 2021) One of the most important concepts in VBA is also one of the least understood. Let's shine a light on the Component Object Model.

High Level Overview of COM: (Nov 20, 2021) This whirlwind tour of the Component Object Model technology will jump start your journey of automating Excel from VBA in Access.

Early Binding vs. Late Binding: The Essential Guide for VBA Developers: (Nov 27, 2021) The Absolute Minimum Every VBA Developer Absolutely, Positively Must Know About Early and Late Binding in COM (No Excuses!)

Microsoft Office COM Automation Libraries: (Dec 3, 2021) The VBA developer's guide to automating Microsoft Office applications: early vs late binding; CreateObject vs GetObject; and tips on cleaning up after yourself.

COM Server Types: In-Process vs. Local vs. Remote: (Dec 27, 2021) There are three basic types of COM servers: in-process, local, and remote. What do they have in common? What are the differences? Let's explore.

The IUnknown Interface: (Mar 7, 2022) All COM objects are required to support at least one interface: the IUnknown interface. In this short article, we explore the three methods of IUnknown.

The IDispatch Interface: (Mar 25, 2022) For a COM object to support late binding in VBA, it must implement the IDispatch interface. Let's explore IDispatch and its four methods.

Overcoming Programming Language Barriers with COM: (Mar 26, 2022) COM is sort of like a Chinese restaurant.

Early vs. Late Binding at the Chinese Restaurant: (Mar 28, 2022) In this continuation of our Chinese restaurant-COM metaphor, we expand the example to illustrate the differences between early and late binding.

Managing Memory in COM: (Mar 30, 2022) We continue on with our restaurant analogy to explain the concept of reference counting and COM object cleanup.

Reference Counting's Fatal Flaw: Circular References: (Mar 31, 2022) We look at several types of circular references along with a handy tool that you can use to help identify circular references in your own code.

Loading VBE Addins - A Windows Registry Tour: (Apr 25, 2022) Let's pull back the curtain and see how VBA loads VBE COM add-ins via a series of registry calls.

ActiveX vs. Standard DLLs: (Jun 15, 2022) What's the difference between an ActiveX (COM) and Standard DLL? When would you choose one over the other?

Combo Boxes

["Combo Boxes" tag page]: Show all articles with the tag "Combo Boxes" (including those where "Combo Boxes" is a secondary tag).

Combo Boxes and Target Sizes: (Jun 7, 2021) Just like in darts, it's easier to hit a larger target when using the mouse. With this in mind, let's make our combo boxes more user-friendly.

Combo Boxes: Use Responsibly: (Jun 8, 2021) Comic book legend Stan Lee captured the essence of the Microsoft Access combo box control in six words, "With great power, comes great responsibility."

Combo Box Benefits: (Jun 9, 2021) An overview of some of the benefits of combo boxes, including autocomplete, hierarchical searching, and auto-updated most frequently used lists.

Progressive Combo Box Filtering: (Jun 10, 2021) Autocomplete for combo boxes with hundreds of thousands of entries? It's possible with the progressive filtering technique.

Multi-Column Progressive Combo Box Filtering: (Jun 11, 2021) You, too, can learn to filter your combo boxes by every visible column.

Cascading Combo Boxes: (Jun 12, 2021) Cascading combo boxes are one of the best ways to find data in a fixed hierarchy. Here's what the concept looks like in action.

Lazy Loading Combo Boxes: (Jun 14, 2021) Don't load tens of thousands of records into a combo box. Instead, wait for the user to start typing, and then load only what they need.

5 Advanced Combo Box Techniques to Take Your Access Forms to the Next Level: (Jun 16, 2021) Increase the combo box's "target area," lazy load your data, add progressive filtering (for multiple columns!), and implement dead-simple cascading.

A Wonderful, Magical Class Module: (Jul 30, 2021) Imagine a single class module you can use for progressive combo box filtering, lazy loading combo boxes, AND multi-column filtering!

A Lazy-Loading Combo Box In Only 3 Lines of Code: (Jul 31, 2021) Combo boxes that pull down too many records can slow down your Access forms. Boost performance with my class module and 3 lines of code.

ComboBox .Undropdown Method: (Aug 11, 2021) Combo boxes have a .Dropdown method. But what if you want the opposite: a .CloseDropdown method? This tip from Adam Waller has the answer.

How to Add a Catch-all Value to a Combo Box in Access: (Oct 29, 2021) Two ways to let your users choose "All of the above" when using your combo boxes.

Dealing with Inactive Items in a Combo Box Row Source: (Feb 15, 2022) There are many ways to deal with inactive RowSource items in combo boxes. Here's a no-code technique that I find myself coming back to time and again.

Commentary

["Commentary" tag page]: Show all articles with the tag "Commentary" (including those where "Commentary" is a secondary tag).

Sympathy for the devil?: (Sep 1, 2020) Microsoft Access is not the devil. You can use it to write great software. You can use it to write crappy software. I'm here to help you write more of the former and less of the latter.

No Longer Set: (Sep 3, 2020) One of the most important features of Microsoft Access is backwards compatibility. And make no mistake, backwards compatibility *is* a feature.

Past is Prologue: (Sep 23, 2020) A personal reflection on my software development journey. There's more to creating great software than knowing how to write code.

Building Your Library: (Sep 28, 2020) Thirteen years ago, I chose to maintain a folder of text files rather than a single Access database library. I've never once regretted that decision.

Weekend Warriors: (Oct 1, 2020) Wherein I compare keyboard warriors to actual warriors.

Lightweight Forms? Just Don't: (Oct 2, 2020) Lightweight forms make your code harder to read and debug, but if your users have monitors with high enough refresh rates, they'll appreciate the effort.

The Curse of Reliable Software: (Oct 4, 2020) How does one avoid the reliability paradox? One option is to intentionally write unreliable, buggy software. There's a better option.

Two Ways to Burn: (Oct 5, 2020) Burning cardboard is a lot like a large data migration. You can do it all at once or slowly over time.

How Not to Propose: (Oct 8, 2020) Features don't sell software.

The Golden Rule of Data Migrations: (Oct 16, 2020) The fastest and most reliable way to run a migration is to repeat it many times. I call this the "Repetition Paradox."

Cruft Sale!: (Nov 7, 2020) Everything must go!!! Dead code, obsolete reports, and bunches of binary backups! No offer too big or too small!

Web Apps - Bane of my Existence: (Nov 11, 2020) Whatever modicum of credibility I may have had with "real programmers" I am about to douse in gasoline and light on fire with this article.

7th Grade Career Day: (Nov 21, 2020) Using this approach, I manage to teach multiple programming concepts to absolute beginners in the span of about fifteen minutes.

Backward Compatibility: A Go Perspective: (Nov 30, 2020) "What actually makes code, advice, and tutorials obsolete?" Let's explore the answers as they relate to the Go programming language and MS Access.

Copying and Pasting Code with Purpose: (Dec 11, 2020) The first commandment of software development is, "Thou shalt not copy and paste code." Sometimes that's wrong.

How It's Always Been Done: (Dec 31, 2020) Good programmers know how to code. Great programmers know why. The best programmers question why.

Access Migrations: (Jan 2, 2021) Data migrations are high risk operations. You can't prepare for every pitfall, but a good plan will maximize your chances of success.

Declaration of Database Design: (Jan 15, 2021) Altering the schema of a production database is not a step to be taken lightly. But when requirements dictate, it must be done.

You're Not an Impostor: (Feb 19, 2021) You're good enough, you're smart enough, and doggone it, people like you.

Recovering From Code Loss: (Feb 28, 2021) Access just crashed while you were writing code. When you last saved will determine how long it takes to recover, but it's not a linear relationship.

Reducing Lost Code Recovery Time: (Mar 3, 2021) How do you reduce your recovery time when you've lost a bunch of code you just wrote? To misquote Bart Simpson, "Version control, my man."

Some Bugs are Better than Others: (Mar 25, 2021) Not all bugs are created equal. Avoid the expensive ones by making more of the ones that are easy to find and fix.

Join Me at Access DevCon 2021: (Mar 28, 2021) I will be presenting the about-to-be-released TwinBasic project from vbWatchdog developer, Wayne Phillips. Join me on April 22-23.

The Two Keys to Building Great Access Applications: (Jun 17, 2021) The best Access applications prioritize data discovery and efficiency.

Microsoft Access's Multiple Personality Disorder: (Jun 26, 2021) The dual nature of Access–and the ignorance of this reality–is a major source of the shade that "real programmers" throw its way.

Don't Write Clever Code: (Jul 14, 2021) There are two problems with clever code. 1) The next person might not know what you were doing. 2) They might not know if *you* knew what you were doing.

Microsoft and VBA: A Love(less) Story: (Jul 22, 2021) Whatever happened to the passion Microsoft once had for VBA? From love story to marriage of convenience, this article is one weird ride.

Evolution of a Business Application: (Aug 13, 2021) Before you commission that custom web application project, it pays to validate that the business process even warrants such a significant investment.

Access vs. Enterprise Software: A False Choice: (Aug 14, 2021) Beware of strawman arguments against Microsoft Access.

The Software Reliability Paradox: (Sep 22, 2021) The most reliable software holds the potential to cause the greatest harm. Examples abound, from my own $86K mistake to a devastating Russian hack.

Eliminating Friction: (Oct 19, 2021) The key to becoming a better developer is to make it so The Right Way is also The Easy Way.

5 Types of Documentation: (Nov 9, 2021) Each type of documentation has unique strengths and weaknesses. Knowing when and how to use each is an important skill for every developer.

How to Request New Features for Microsoft Access: (Nov 11, 2021) After a long and conspicuous absence, Microsoft has finally published a new website where you can submit and vote on feature requests.

Let's Make Access More Version-Control Friendly: (Nov 12, 2021) Hey! Wouldn't it be great if Access was version-control friendly out of the box? If you agree, head over to the Access feedback portal and vote for my request.

Access Dataverse Connector: (Nov 23, 2021) Did you ever think to yourself, "I wish there was a way to make my back-end data less flexible *and* less powerful?" Good news; your wait is over!

3 Benefits of Writing Code Backwards: (Nov 24, 2021) Ignore those compile errors and start writing your calling code before your routines. This approach has many benefits.

The Key to Navigating Unfamiliar Territory Without a Map: (Nov 29, 2021) How I successfully led a 60-vehicle military convoy at 23 years old without knowing what I was doing or where I was going.

The State of Access Today: (Nov 30, 2021) What's the state of Microsoft Access in 2021: thriving, alive, dying, or dead? If you only know Access by reputation, the answer may surprise you.

Code is WORM: Act Accordingly: (Jan 31, 2022) Write Once. Read Many. The cost of avoiding shortcuts when writing code is far exceeded by the benefits you'll get when reading it.

Is Microsoft Access a Good Development Platform in 2022?: (Feb 8, 2022) Microsoft has embraced the mantra of "move fast and break things." For Access, though, Microsoft is only delivering on the latter part of that promise.

Yes, VBA-Enabled Office Docs are a Significant Threat: (Feb 17, 2022) VBA-enabled documents are commonly used to open the door for more virulent malware.

Expect the Unexpected: (Feb 25, 2022) Getting ready to start a complex project? Stressing about what might go wrong? Here's some advice to help lower that stress level.

The Curse of Knowledge: (Jul 22, 2022) Even the world's worst programmer knows more about programming than most small business owners or department managers.

PICNIC: The Underlying Cause of Many Technical Support Calls: (Sep 14, 2022) A PICNIC is the most frequent source of problems on technical support calls.

Avoid Context Switching for More Readable Code: (Sep 16, 2022) Writing code is like juggling. But mixing code, queries, and global state is like juggling balls, bowling pins, and running chainsaws.

The Problems with Boilerplate Code: (Oct 12, 2022) Copy. Paste. Modify. Repeat. Writing and maintaining boilerplate code is a necessary evil in VBA.

Follow-Up: Avoiding Context Switching: (Oct 24, 2022) It doesn't matter which context you are working in–VBA or queries–the key is to pick one and stick with it.

How to Know When to Turn Lines of Code Into a Standalone Routine in VBA: (Dec 5, 2022) DRY vs. YAGNI. Don't Repeat Yourself or You Ain't Gonna Need It? Sometimes it's not obvious whether a block of code would be useful as a standalone routine.

Convenience Functions

["Convenience Functions" tag page]: Show all articles with the tag "Convenience Functions" (including those where "Convenience Functions" is a secondary tag).

Avoiding the Error "invalid reference to the property CurrentRecord": (Jul 1, 2021) Error number 2455, "You entered an expression that has an invalid reference to the property CurrentRecord," is annoying, but there is an easy fix.

The TrySetFocus Convenience Function: (Jul 6, 2021) The TrySetFocus function attempts to set focus to a control. If the operation succeeds, it returns True; otherwise, it returns False.

Convenience Functions (My Secret Weapon to Create Self-Commenting Code): (Jul 8, 2021) How much can you really gain by replacing one line of code with a different, functionally equivalent line of code? Quite a bit, as it turns out.

Conventions

["Conventions" tag page]: Show all articles with the tag "Conventions" (including those where "Conventions" is a secondary tag).

VBA Squeeze Box: (Sep 20, 2020) I discussed previously the differences between passing by value and passing by reference. I now want to discuss how and when I use each in my own code.

Enum Type Naming Convention: (Oct 9, 2020) The combination of "IntelliSense overload" and "global identifier case changes" convinced me I needed a different approach.

Comment Continuations: (Dec 3, 2020) Using ellipses to "group" comments separated by intervening lines of code.

Googleable Field Names: (Feb 7, 2021) Using globally unique field and table names will make it easier to identify where such fields and tables are used throughout your application.

Beautiful Blocks of Boilerplate: (May 3, 2021) Using the colon character to join multiple lines of code all willy-nilly can lead to messy code. But, used judiciously, it can create beauty from chaos.

Database Date Field Naming Convention: (Sep 21, 2021) Naming is hard. When it comes to naming conventions, the key is to keep things simple. Here's how I like to name the date and time fields in my databases.

Naming Conventions Matter: Making Wrong Code Look Wrong: (Oct 14, 2021) Joel Spolsky and Antonin Scalia join forces to help illustrate the importance of sensible code naming conventions.

My File System Variable Naming Convention for VBA: (Aug 9, 2022) "SourcePath" may be one of the worst variable names ever written. Is it the full path to a source file? Is it the folder where my source files are located?

Database Design

["Database Design" tag page]: Show all articles with the tag "Database Design" (including those where "Database Design" is a secondary tag).

Autonumber Primary Keys: (Nov 17, 2021) They're fake ... and they're spectacular!

When to Store Numbers as Text: (Nov 25, 2021) Introducing the "Numeroliteral Test," a one-question heuristic for deciding whether to store numeric data in a character-based field.

The 13 Kinds of Business Application Tables: (May 27, 2022) Database tables in a line-of-business application generally fall into one of these thirteen categories.

Reader Q&A: Single-Row Tables: (Dec 8, 2022) Are single-row tables something you should use or not? Can they be trusted? I answer that and more in this installment of Reader Q&A.

Sample Database Schemas for the Database Design Phase: (Dec 15, 2022) The most important phase of any Microsoft Access application project is the database design. This site has tons of sample schemas to get you started.

Beware of "Over-Normalizing" Your Database: (Jan 2, 2023) Sometimes the two primary goals of database normalization--reduced data redundancy and improved data integrity--are at odds with each other.

Debugging

["Debugging" tag page]: Show all articles with the tag "Debugging" (including those where "Debugging" is a secondary tag).

Debugging Automation Errors: (Nov 19, 2020) Come join me on a journey debugging hard-to-reproduce "Automation error" bugs.

How to Set a Breakpoint in Startup Code in VBA: (Dec 4, 2021) Ever set a breakpoint in your Access application's startup code, only to have it get cleared before it got hit? There's a simple workaround.

Checking Specific TCP Port Access to a Remote Machine: (Jan 11, 2022) Troubleshooting network connections is tough. Generic error messages make it hard to identify the root of the problem. This PowerShell cmdlet can help.

Troubleshooting SQL Server Connection Errors: (Feb 28, 2022) "SQL Server does not exist or access denied." One error. Dozens of possible causes. Read on for a bunch of practical troubleshooting tips.

Find the Yellow Highlighted Line When Debugging in VBA: (Mar 3, 2022) Did you ever lose your place while debugging in VBA? Here's an easy way to find it.

Troubleshooting Access Hanging When Switching to Design View: (Mar 12, 2022) How I used two low-level tools--ProcMon and WireShark--to figure out why Access was taking forever to switch to design view in forms and reports.

Troubleshooting the "Unable to create target directory" Error in PDQ Deploy with ProcMon: (Apr 7, 2022) Let's use my jack-of-all-trades troubleshooting tool--Process Monitor--to find the root cause of a recurring PDQ Deploy error.

Breaking Down Windows Error Codes: (May 23, 2022) Did you know there is a method to the madness behind those crazy-looking VBA error numbers like 0x80070005 or its decimal equivalent -2,147,024,891?

Fixing a Persistent "Write Conflict" Error: (Jun 10, 2022) If you are getting consistent "Write Conflict" warnings when using bound forms to update SQL Server tables with datetime fields, there may be an easy fix.

3 Benefits of Documenting Your Debugging Process: (Sep 5, 2022) It may sound counterintuitive, but taking the time to document your debugging process will save you time--both now and in the future.

Debug Documentation: Signal vs. Noise Edition: (Jan 19, 2023) Debugging an issue can generate a lot of content. This technique helps you keep track of and find the parts that really matter.

Defensive Programming

["Defensive Programming" tag page]: Show all articles with the tag "Defensive Programming" (including those where "Defensive Programming" is a secondary tag).

Defensive Programming: (Oct 10, 2020) Don't build digital Maginot Lines. Program your defenses in depth.

The RecordsAffected Property is a Powerful Tool for Defensive Programming: (Aug 4, 2021) As developers, we need to constantly be thinking about how to handle unknown unknowns. The RecordsAffected property helps us do that.

Reduce Logic Errors in Critical Code: (Sep 30, 2021) Software Developers Can Almost Eliminate Logic Errors With This Powerful Technique

5 Ways to Reduce Logic Errors Using Automated Double-Checks: (Oct 1, 2021) Identify the critical functions in your application. Then, apply one or more of these techniques to ensure that if they break, someone will notice.

Data Validity Checks: (Oct 18, 2021) Increase the quality of your existing data by running it through a series of validity checks and showing your users the results.

Frictionless Validity Checks: (Oct 30, 2021) Let's apply the concept of frictionless development to the defensive programming technique of data validity checks.

A Safe Way to Add Temporary Code: (Feb 26, 2022) A quick tip to ensure your temporary code disappears when the sun sets.

In Defense of Security Through Obscurity: (Jun 3, 2022) There are two key elements to defending a military position: cover AND concealment. It's not an either-or proposition.

Guard Clauses: (Jan 16, 2023) Guard clauses are one of my favorite low-friction defensive programming tools.

3 Techniques for Programming Reversible Processes: (Feb 1, 2023) How would you recover from a large accidental UPDATE operation? You'd better be able to answer that question *before* it happens.

Deployment

["Deployment" tag page]: Show all articles with the tag "Deployment" (including those where "Deployment" is a secondary tag).

Adding a Machine-Wide Trusted Location in MS Access: (Feb 14, 2022) Let me show you how to add a Trusted Location for every user on a device even if that device doesn't have a full copy of Microsoft Access.

Mark of the Web (MOTW) Support Among Zip Utilities: (Jun 8, 2022) What happens to the Mark of the Web when you extract files from a downloaded .zip file? It depends on what you use to do the extraction.

Distributing One-Time Data "Hot Fixes": (Jul 8, 2022) Rolling out changes to *production data* when you don't have direct access to that data can be tricky. This tip makes the process easier.

Creating Pre-packaged Software with Microsoft Access: (Jul 21, 2022) Microsoft Access is a poor choice for creating pre-packaged software applications. But does it really have to be that way?

DevCon

["DevCon" tag page]: Show all articles with the tag "DevCon" (including those where "DevCon" is a secondary tag).

Access DevCon Vienna 2022 - Day One Recap (Part 1): (Apr 30, 2022) I cover Maria Barnes's Dataverse Connector talk and Microsoft's Access Roadmap update in this Access DevCon Vienna 2022 recap.

Access DevCon Vienna 2022 - Day One Recap (Part 2): (May 2, 2022) I cover Kevin Bell's appLauncher service, Chris Arnold's SSMS-like Access tool, my COM talk, and Colin Riddington's Google Maps API demo in this Day 1 DevCon Vienna 2022 recap.

Access DevCon Vienna 2022 - Day Two Recap (Part 1): (May 3, 2022) I cover my twinBASIC Update, VBA Tips and Tricks with AG, Word Automation with Crystal Long, and Peter Cole's Themes talk in this Day 2 DevCon Vienna 2022 recap.

Access DevCon Vienna 2022 - Day Two Recap (Part 2): (May 4, 2022) I cover Northwind 2.0, Continuous Datasheets with Chris Arnold, Peter Cole's 64-bit VBA converter, and Colin Riddington's Translate & Speak tool in this Day 2 DevCon Vienna 2022 recap.

Access DevCon Vienna 2022 - Access Roadmap Update: (Sep 8, 2022) Highlights include a new "High Confidence" approach to the roadmap, a sneak peek at the modern browser control, and background on the Monster Bug.

DoEvents

["DoEvents" tag page]: Show all articles with the tag "DoEvents" (including those where "DoEvents" is a secondary tag).

Demystifying DoEvents: (Jul 12, 2021) The DoEvents function may be the single most misunderstood piece of code in the entire VBA language. In this series of articles, I'll try to remedy that.

How to Teach a Six-Year Old About the DoEvents Function: (Jul 15, 2021) I challenge you to read this article without laughing or learning anything new about the DoEvents function.

How to Use the DoEvents Function: A Demonstration: (Jul 16, 2021) The demonstration and downloadable sample code in this article make it easy to understand how DoEvents works.

When (or Should I Say, How Often) to Call DoEvents: (Jul 17, 2021) Too few calls to DoEvents, and your app may appear to be "(Not Responding)." Too many calls to DoEvents, and your app will run slow. Let's Goldilocks this thing.

A High-Level Overview of the DoEvents Function Call: (Jul 19, 2021) Why does calling DoEvents save us from the dreaded "(Not Responding)" treatment? It's all about handling "Windows Messages."

How DoEvents Works: The Nitty-Gritty Technical Details: (Jul 23, 2021) A peek behind the scenes at the inner workings of the DoEvents function.

DoEvents vs. Repaint in Microsoft Access: (Jul 26, 2021) Can you use the Repaint method in place of the DoEvents function? It depends on what you're trying to do. Let's explore with some sample code.

Error Handling

["Error Handling" tag page]: Show all articles with the tag "Error Handling" (including those where "Error Handling" is a secondary tag).

Error Handling Evolution: (Sep 6, 2020) How you handle errors says a lot about you as a programmer. Most people evolve with experience in how they handle errors. From the most naïve to the most advanced, here is what that evolution looks like.

Throwing Errors in VBA: (Oct 11, 2020) Introducing a frictionless alternative to Err.Raise.

Graduate Level Error Handling: (Oct 14, 2020) Once again, I borrowed an idea from Python. To smuggle this concept into VBA, I turned to a rarely-used language feature...

Why "Add an Error Handler to Every Routine" is Bad Advice: (Nov 10, 2021) For every complex problem, there is an answer that is clear, simple, and wrong. (Shocking, I know.)

Showing User-Friendly Error Messages for Missing Data on Bound Forms in MS Access: (Jan 13, 2023) Here are two ways to show custom error messages on a bound form using (1) the Form_BeforeUpdate event or (2) the Form_Error event.

Events

["Events" tag page]: Show all articles with the tag "Events" (including those where "Events" is a secondary tag).

The ArrowKeyNav Routine: (May 1, 2021) Enable Excel-like navigation in your continuous forms by overriding the default behavior of the up and down arrow keys.

ArrowKeyNav Presentation: (May 6, 2021) A list of resources and further reading to support my presentation on Navigating Continuous Forms using WithEvents.

Many Objects, One Class Module: (May 8, 2021) Check out this trick for reducing boilerplate code: maintain a private collection of objects that are instances of the class itself.

ComboBox Dropped Down State: (May 10, 2021) Overriding the up/down arrow key behavior improves the user experience on a continuous Access form. But what if the user drops down a combo box?

AddNew Increments AutoNumber Fields: (May 11, 2021) Thanks to Ben Clothier, we've got another improvement to our Arrow Key Navigation class.

The ArrowKeyNav Journey: (May 20, 2021) A full breakdown of my weArrowKeyNav class module that uses WithEvents to override the default up and down arrow key behavior in continuous Access forms.

Fluent API

["Fluent API" tag page]: Show all articles with the tag "Fluent API" (including those where "Fluent API" is a secondary tag).

Fluent Interfaces: (Jan 10, 2021) It's probably irresponsible of me to share the following technique with you because you'll be so tempted to abuse it. But let's do it anyway.

Diving Deeper into the World of Fluent APIs: An Unusual Way of Constructing Class Modules: (Nov 29, 2022) Martin Fowler first coined the term fluent interfaces back in 2005. What are they, what do you need to know about them, and what do they look like in VBA?

When to Build Fluent APIs: (Nov 30, 2022) Fluent programming interfaces can be your best friend or your worst enemy. So how do you know when they are appropriate to use?

Form Design

["Form Design" tag page]: Show all articles with the tag "Form Design" (including those where "Form Design" is a secondary tag).

Form Design Gallery: (Dec 29, 2021) An ever-expanding gallery of Microsoft Access form design tips, techniques, and inspiration.

Master Lookup Form: (Dec 30, 2021) The Master Lookup Form is the hub of my Access applications.

Progress Tracker Form: (Dec 31, 2021) For recurring processes that have lots of required subtasks but with no dependencies among the subtasks, I turn to my Progress Tracker Form.

Two-Way Many-to-Many Form: (Jan 1, 2022) Presenting many-to-many relationships intuitively is tricky. I use this style of form when the two sides of the relationship have a small number of records.

IslaDogs: Getting Creative with the Access Application Interface: (Jan 4, 2022) This one-hour video from Colin Riddington (aka IslaDogs) is jam-packed with API-based Access user interface hacks.

Modern Message Boxes in Access: (Jan 5, 2022) These modern message boxes from Kevin Bell will help set your Access applications apart from the crowd.

Tabbed Master-Detail Form: (Jan 26, 2022) The tabbed master-detail form is the heart of my Access applications. The first tab has record details, while the other tabs provide subforms for one-to-many relationships.

Add a Custom Right-Click Menu to an Access Control: (Feb 2, 2022) It's easier than you might think to add a right-click menu to a control on your Access form.

Overlapping Windows vs. Tabbed Documents: (Mar 22, 2022) Access gives you two options for displaying forms and report objects: windows or tabs. Read on for the advantages of each and which one I prefer.

5 Ways to Set a Default Font on Microsoft Access Forms: (May 6, 2022) If you don't like the default fonts in MS Access, you don't have to change them one control at a time. Here are 5 techniques to simplify the task.

Abbreviations in Lookup Tables: (May 19, 2022) One way to boost the signal-to-noise ratio on your continuous forms is to use abbreviations rather than full descriptions for lookup tables.

Choosing the Right Font: (Jun 1, 2022) Fonts fall into six main categories. There is no one "best" type of font. Rather, each type serves different purposes.

Modern On/Off Button in Access: (Jul 26, 2022) Leave those boring checkboxes behind and move into the 21st century with these modern on-off switches for Microsoft Access. Very little code required!

Triple-State Modern On/Off Switch in Access: (Aug 19, 2022) Yes, No, or I Don't Know (or Don't Care). With this updated design, you can offer your users a third option with your modern on/off switches.

Forms

["Forms" tag page]: Show all articles with the tag "Forms" (including those where "Forms" is a secondary tag).

Lazy Loading a Tabbed Form in Microsoft Access: (Aug 31, 2021) How to use "just-in-time population" to dramatically decrease the load times of complex Access forms.

Escaping Semicolons in a Multi-Column Access ListBox: (Oct 2, 2021) When adding items to a multi-column list box, the semicolon character is used to separate columns. What if the items themselves contain semicolons?

2 Ways to Escape Leading Quotes when Adding Items to a List Box: (Oct 4, 2021) Leading quotation marks can cause problems when adding items to a list box or combo box. Here are 2 easy ways to deal with the issue.

AutoFitDatasheet: A Function to Prettify Your Access Datasheets: (Oct 20, 2021) This routine resizes the columns of the active datasheet window (plus the window itself) based on its contents to make the best use of the available space.

6 Techniques to Control Where Forms Open On-Screen in Access: (Mar 23, 2022) With Overlapping Windows in Access, you need to think about where each form should open on-screen for the user. Here are 6 techniques to help you do that.

7 Ways to Loop Through Controls on a Microsoft Access Form: (Sep 6, 2022) There are many ways to use VBA to hide/show or lock/unlock groups of controls on an Access form. Here are seven different techniques you can use.

The Reason MS Access Forms and Reports are Limited to 22 Inches: (Nov 16, 2022) With today's large monitors, many Access developers have bumped into the 22" maximum form width. But do you know why it's not 21" or 23"?

Hidden Features

["Hidden Features" tag page]: Show all articles with the tag "Hidden Features" (including those where "Hidden Features" is a secondary tag).

Database Properties for Thee: (Sep 11, 2020) The DAO Database object has a Properties collection. You can read through the list of properties to extract saved database options. You can also add your own properties to the object.

Wherefore art thou, database properties?: (Sep 12, 2020) In my previous post, I talked about adding custom properties to the database object. I covered how to do it, but did not go into any detail about why you might want to do it. Let's remedy that now.

Expressions vs. Code: (Oct 3, 2020) When is code not code? When it's an expression. What's the difference and who really cares? Let's explore.

A Rounding We Will Go: (Oct 6, 2020) Two kinds of rounding, the VBA language spec vs. the Office VBA implementation, and a drop-in replacement for VBA.Round().

Requery a Form in Place: (Oct 12, 2020) Form.Recordset.Requery. That's it. That's the whole article.

VBA Alchemy: Turning Methods Into Properties: (Oct 19, 2020) One can check the status of screen painting in Excel, but not in Access. This turns out to be an important shortcoming. Let's remedy it.

Blast From the Past: (Oct 26, 2020) Why use keyboard shortcuts from Access 2003 when developing in 2020? Because starting with Access 2007, the new shortcuts suck.

VBA's Case Changing "Feature": (Nov 14, 2020) VBA likes to change the casing of our code (upper/lower/mixed). It may seem random, but it's not. Read all the details here.

Careful What You Watch For: (Dec 8, 2020) Can the simple act of creating a Watch change the behavior of your code while debugging? Why yes, yes it can.

Debugging Private Procedures: (May 7, 2021) After more than 14 years as a VBA developer, I recently discovered that you can debug private procedures without temporarily making them public!

How to Check if a User Clicked [Cancel] on an InputBox in VBA: (Aug 30, 2021) It's possible to distinguish between a user clicking [OK] on an empty box or clicking [Cancel]. You just need to use this simple trick.

Expressions vs. Code: Implicit Type Conversion: (Sep 7, 2021) In Microsoft Access, is a whole number literal implicitly treated as a Long or an Integer or a Double? As it turns out, it depends on where you ask.

Hidden Feature: Drag and Drop Access Objects Between Files: (Dec 2, 2021) Skip the "Import Access Objects" dialog screens and use your mouse to move Tables, Queries, Forms, Reports, and code modules between Access files.

DefType Statements in VBA: The Dark Side of Backward Compatibility: (Jan 10, 2022) Young VBA programmer, be not tempted by the dark side. DefType statements must be understood, but never used!

Access Error Number Message Lookup: (Jan 20, 2022) Did you ever come across an error number in your Access code--maybe in an If or Select Case statement--and wonder what it was for? Wonder no longer.

Quick and Dirty For Loops in the Immediate Window: (Feb 21, 2022) Did you know that you can write and execute entire For Loops in the VBA Immediate Window?

Inspecting the End of a Long Variable Value in VBA: (Feb 23, 2022) You know how VBA cuts off the right side of a really long variable when inspecting its value via mouse hover? Did you know you can show the right side instead?

Declaring and Initializing Variables in the Same Line in VBA: (Feb 24, 2022) You can't declare and initialize a variable in a single code *statement* in VBA, but you can do it in a single *line* of code with this handy trick.

How to Show Hidden Items in the VBA Object Browser: (Apr 11, 2022) One possible fix for the "Cannot jump to '|' because it is hidden" error is to show hidden members in the VBA object browser.

Why Does My Access Web Browser Control Default to IE 7?: (Apr 27, 2022) If web pages don't look right on your Access web browser control, it might be due to a little-known registry setting.

HOW TO: Run Scheduled Tasks with Microsoft Access: (May 9, 2022) This underused MS Access command-line argument opens up a whole new world of possibilities when it comes to scheduling recurring tasks in Access.

VBA Immediate Window Line and Character Limits: (Jul 1, 2022) Don't take my word for it (or anyone else's on the internet, for that matter). Prove the limits to yourself with some simple VBA.

AccHitTest: Returns the Form Control the Mouse Clicked On: (Aug 1, 2022) This undocumented form function can help you write a generic click event for label controls.

WizHook: A Hidden Access Object With Intriguing Potential: (Oct 25, 2022) Font-aware AutoFit of text and combo boxes, auto-bracketing of illegal field names, sorting an array of strings...the possibilities are finite!

Select Entire Sub or Function in VBA with a Double-Click: (Nov 14, 2022) Yet another hidden feature of the VBA editor that eluded me for more than fifteen years.

Select Entire Module in VBA With Control + Click: (Nov 15, 2022) Learn 4 different ways to select the entire contents of a VBA module, plus a bonus keyboard shortcut tip for switching between two active code modules.

Access End-User Shortcuts: (Nov 24, 2022) Shortcut keys to toggle the dropdown state of a combo box, copy field values from the previous record, enter the current date and time, and more.

Dark Mode in VBA: (Dec 13, 2022) VBA may not have a preset "Dark Mode" like other modern development environments, but it's not hard to create one yourself.

Holiday

["Holiday" tag page]: Show all articles with the tag "Holiday" (including those where "Holiday" is a secondary tag).

Merry Christmas: (Dec 25, 2020) "...the shepherds said to one another, 'Let’s go to Bethlehem and see this thing that has happened, which the Lord has told us about.'"

Happy Easter: (Apr 4, 2021) “Don’t be alarmed,” he said. "You are looking for Jesus the Nazarene, who was crucified. He has risen! He is not here."

Merry Christmas: (Dec 25, 2021) "But the angel said to her, 'Do not be afraid, Mary; you have found favor with God. You will conceive and give birth to a son, and you are to call him Jesus.' "

Happy Easter: (Apr 17, 2022) "Why do you look for the living among the dead? He is not here; he has risen!"

Merry Christmas: (Dec 25, 2022) "...She will give birth to a son, and you are to give him the name Jesus, because he will save his people from their sins.”

Humorous

["Humorous" tag page]: Show all articles with the tag "Humorous" (including those where "Humorous" is a secondary tag).

Reproducing Errors: (Oct 7, 2021) A physicist, a mechanic, and a programmer were in a car driving over a steep alpine pass when the brakes failed...

Interfaces

["Interfaces" tag page]: Show all articles with the tag "Interfaces" (including those where "Interfaces" is a secondary tag).

Intermediate

["Intermediate" tag page]: Show all articles with the tag "Intermediate" (including those where "Intermediate" is a secondary tag).

Interfaces, Conceptually: (Oct 20, 2020) Interfaces can be a difficult concept to grasp conceptually. To help make sense of the concept, consider these real world examples.

Interfaces, Practically: (Oct 21, 2020) A real world example using Active Directory lookups.

Backward-Compatible Refactoring: (Oct 22, 2020) How can you completely change the way you interact with a class without breaking backward compatibility? Interfaces.

Cookie Cutter Forms: (Oct 23, 2020) How do you reuse a form with external dependencies in multiple projects? Interfaces.

Dependency Injection (sort of): (Oct 24, 2020) For a few common dependencies, we can cheat by using a singleton class. Within that class, we'll type those dependencies as interfaces.

Cleaner IntelliSense: (Oct 25, 2020) How to clean up your object's auto-complete dropdown list when it starts to look like that of the MacBook Wheel.

Debugging Sideways Images in Access: (Nov 22, 2020) Ever import a normal-looking image in Access, only to have it turn sideways on you in the image control? The problem may lie in the EXIF data.

Decompile then Deploy: (Nov 23, 2020) Save disk space and increase startup performance of your program updates by running /decompile before deployment.

Bang! Dot. Default: (Dec 9, 2020) Three ways to reference form and report controls. Which way is best?

VBA Code Generation Trick: (Dec 12, 2020) Using Notepad++ to transform existing code into a VBA string that generates itself.

Data Transfer Objects in VBA: (Dec 13, 2020) You can't create a collection of custom types in VBA. What can we do instead?

The Subtle Dictionary Key Bug: (Dec 15, 2020) Always explicitly call the .Value property when using fields or controls as Dictionary keys. Else the bugs come crawling!

Checklist: Better Access Applications: (Dec 18, 2020) Good. BETTER. Best. Is your Access application good enough to sell?

Short-Circuiting VBA?: (Dec 22, 2020) Beware of clever workarounds for missing language features. Sometimes the simple approach is best.

To Compile or Not to Compile: (Jan 12, 2021) With the proper deployment infrastructure in place, distributing uncompiled Access apps can simplify your life versus compiled Access apps.

Decompile Before Deployment: (Jan 13, 2021) Before deploying my Access applications, I like to strip them down to their bare bones.

Sources of Technical Debt: (Jan 16, 2021) Dealing with technical debt is no fun. It's better to avoid it in the first place. To help with that, here's a list of common sources of technical debt.

Parameterized Constructors in VBA: (Mar 21, 2021) VBA does not allow for parameterized constructors. We can work around that, though, using the Factory pattern and a strong naming convention.

Access Web Browser Control: (Apr 15, 2021) Documentation is scarce for the legacy Access Web Browser Control. And that makes Daniel Pineault's page a goldmine of information.

Come Here Often?: (Jun 3, 2021) When designing a user experience (UX), the single most important question to ask yourself is this: How often will this feature be used?

First, Make It Right (Then Make It Fast): (Jun 28, 2021) In queries, nested IIf statements are fast and (relatively) easy to write. The problem is they are nearly impossible to read.

4 Uses for Transparent Command Buttons in Microsoft Access: (Jul 3, 2021) When you set a command button's Transparent property to True, you won't see it but you can still interact with it. This opens up a world of possibilities.

The "Unset" Enum Item: (Jul 21, 2021) This simple technique is a foolproof way to avoid the sort of logic bug that can live undetected in your codebase for years.

Office 2019 Runs in 64-bit Mode By Default. Here's What That Means for VBA Developers: (Jul 27, 2021) Through Office 2016, default installs used the 32-bit version of the software. Now that 64-bit is the default, it's time to bite the bullet and convert your VBA code.

Enforcing a Single-Row Table in MS Access and SQL Server: (Jul 28, 2021) There are many uses for a table with one--and only one--row in it. Using such a table is simpler if you can rely on the sanctity of its one-row-ness.

Runtime Mode in Microsoft Access: (Aug 12, 2021) There are two ways to force a full version of Access to run a front-end file in runtime mode: the /runtime switch and changing the extension to .accdr.

How to Construct a Bit Mask in VBA: (Aug 16, 2021) What's the safest way to construct a bit mask in VBA? Your preferred approach may be more dangerous than you realize.

4 Ways to Automate Sending Emails from Microsoft Access: (Aug 27, 2021) Manually sending a single email from an email client is easy. Automating email sending, by contrast, is deceptively hard.

CurrentDB and the "Object invalid or no longer set" error: (Oct 6, 2021) Misuse of the CurrentDb function is a common cause of the "Object invalid or no longer set" error. Are you using it safely?

4 VBA PowerShell Functions: (Oct 23, 2021) Microsoft Access MVP Daniel Pineault provides four easy-to-use routines for integrating PowerShell with VBA.

How to Remove the Time Portion From a Date Variable in VBA: (Dec 14, 2021) In this article, I run a series of experiments to explore how different time-stripping approaches work in VBA.

The IIf() Function vs. The IIf() Statement: (Jan 3, 2022) They may look identical, but there is a very important difference in how they get evaluated.

Karl's Catalog: A Checklist of Access Best Practices: (Nov 9, 2022) Karl Donaubauer's checklist of Microsoft Access best practices offers a wealth of information to beginners and professional developers alike.

5 Types of Settings for Microsoft Access Applications: (Jan 31, 2023) How you store settings in Microsoft Access depends on their scope. Understanding the scope of your settings is critical to ensure you store them the right way.

Open the Windows Color Dialog from VBA: (Feb 6, 2023) If you need to get Access color values from your users, this is the easiest way to do it.

Leadership

["Leadership" tag page]: Show all articles with the tag "Leadership" (including those where "Leadership" is a secondary tag).

Leadership Principles: (Oct 19, 2022) If you live by these six principles, it is impossible to fail as a leader.

Leadership Principle: You Can Delegate Authority But Not Responsibility: (Nov 8, 2022) It's not easy to earn the trust of a "subordinate" who's almost twice your age. It's even harder to do it in a single day.

List Fields

["List Fields" tag page]: Show all articles with the tag "List Fields" (including those where "List Fields" is a secondary tag).

ListFields() Part 1: Listing Table Fields in the Immediate Window: (Dec 6, 2022) An easy way to reduce context switching between the VBA IDE and the Access application window is to list table field names in the immediate window.

ListFields() Part 2: An Optional Prefix: (Dec 7, 2022) The ListFields() routine expands to include optional table/alias prefixes for outputting fully qualified field names.

ListFields() Part 3: Field Details: (Dec 9, 2022) In part 3, we add an optional parameter to the ListFields() function to display the field details in the immediate window.

Long-Form

["Long-Form" tag page]: Show all articles with the tag "Long-Form" (including those where "Long-Form" is a secondary tag).

Memory Management

["Memory Management" tag page]: Show all articles with the tag "Memory Management" (including those where "Memory Management" is a secondary tag).

Large Address Aware Flag: (Nov 16, 2021) Getting a lot of "Out of memory" errors in newer versions of Access? This trick can more than triple your available memory in 32-bit versions of Access.

Memory Management in VBA: 3 Keys to Avoiding Memory Leaks: (Mar 29, 2022) Managing memory in VBA is a piece of cake, especially if you follow three simple guidelines.

Virtual vs. Physical Memory in the Context of Microsoft Access: (Nov 23, 2022) Are you noticing more "System Resource Exceeded" and "Out of Memory" errors in newer versions of 32-bit Access? It's not your imagination. Here's what's going on.

Virtual Machine Memory: An Explainer for Access Developers: (Dec 1, 2022) Virtual machines present an interesting twist when it comes to memory management issues in Microsoft Access.

Monitoring Memory Usage in a 64-bit Access Application: (Dec 2, 2022) According to the Windows API, my 64-bit Access application uses more than 2 TB (that's *terra*-bytes) of memory. Something tells me that's not right...

Migration

["Migration" tag page]: Show all articles with the tag "Migration" (including those where "Migration" is a secondary tag).

Mystery of the Ancients: (Sep 1, 2021) The Ultimate Guide to Recovering Password-Protected, Access 97 Format .MDB Files

Convert Common Access Field Defaults to SQL Server: (Apr 21, 2022) Here's the Select Case statement I use to convert common Access field default calculations--Now(), Date(), etc.--to their SQL Server equivalents.

SQL Server Migration Steps: (Jun 7, 2022) My SQL Server migration philosophy consists of two priorities: (1) Avoid disasters and (2) Minimize production downtime.

Scripted SQL Server Migrations: (Jun 9, 2022) Use this batch file to automatically backup a database on one instance of SQL Server and restore it on a different instance of SQL Server.

Military

["Military" tag page]: Show all articles with the tag "Military" (including those where "Military" is a secondary tag).

Presentations

["Presentations" tag page]: Show all articles with the tag "Presentations" (including those where "Presentations" is a secondary tag).

Advanced Combo Box Techniques: (Jun 18, 2021) A list of resources and further reading to support my presentation on Advanced Combo Box Techniques.

Troubleshooting Query Performance: (Mar 17, 2022) A recording of the presentation, a list of resources, and further reading for my presentation on Troubleshooting Query Performance.

Understanding COM - DevCon 2022: (Apr 28, 2022) Links and resources from my talk today at Access DevCon Vienna 2022, Understanding COM.

twinBASIC Update - DevCon 2022: (Apr 29, 2022) Links and resources from my talk today at Access DevCon Vienna 2022, twinBASIC: Happy First Birthday!

3 Access DevCon 2022 Video Recordings Released: (May 12, 2022) Check out the recordings of my twinBASIC Update, Kevin Bell's new AppLauncher service, and Alessandro Grimaldi's VBA Tips and Tricks.

¡twinBASIC Va a Madrid!: (Jun 17, 2022) ¡Hola, Madrid! Muchas gracias a Juanjo Luna por invitarme a hablar en su conferencia anual de Access.

twinBASIC en Español: (Jun 29, 2022) My presentation on twinBASIC to the Spanish Access User Group is now available on YouTube. Go check it out!

Building Ribbons in Code: (Jul 6, 2022) A list of resources and further reading to go with my Access User Group presentation on Building Ribbon Interfaces in Code.

Professional Development

["Professional Development" tag page]: Show all articles with the tag "Professional Development" (including those where "Professional Development" is a secondary tag).

Journey to Access: Part 1: (Sep 25, 2020) Many of the best Microsoft Access applications are written by people with no formal background in software development. Your origin story starts here.

Journey to Access: Part 2: (Sep 26, 2020) The weirdos who enjoy spending lots of time to avoid doing mundane tasks that only take a little time have their own special name: programmers. Welcome to our very weird club.

Journey to Access: Part 3: (Sep 27, 2020) A morass of Word documents and Excel workbooks--the invasive plant species of the Windows world--overgrowing your file system like so much digital kudzu.

One Step at a Time: (Jan 29, 2021) To reach great heights, take small steps.

Growing a Business: (Feb 13, 2021) I used to think owning a business was scary. And then I decided to start growing it.

Equal Parts Excited and Terrified: (Mar 29, 2021) You know you’ve found a worthy challenge when you are equal parts excited and terrified to take it on. Because that is how you grow.

Access DevCon 2021: Day 1: (Apr 22, 2021) If you weren't able to make it to virtual Access DevCon Vienna 2021, here's what you missed on Day 1.

Access DevCon 2021: Day 2: (Apr 24, 2021) If you weren't able to make it to virtual Access DevCon Vienna 2021, here's what you missed on Day 2.

The Gambler: (Aug 17, 2021) The most consequential piece of business advice I ever received came from the fictional owner of Pritchett's Closets & Blinds.

"This feels weird.": (Sep 20, 2021) My nine-year-old son got hit in the head at soccer practice the other day. His reaction reminds me of my own professional software development journey.

How to Write a Daily Article: (Nov 4, 2021) Publishing an article every day is not for the faint of heart. But the benefits compound if you can stick with it.

UNC Alias for a Local Folder: (Nov 13, 2021) The subst command lets us mimic mapped network drives. But what if your backend tables are linked using UNC paths? Don't worry. We can handle those, too!

$5,999: Microsoft's Insane Price for Access 2013: (Jul 20, 2022) Microsoft does not make it easy to buy old versions of Access, even though you need them to distribute compiled .accde files for *still-supported* runtimes.

The Robot, the Technician, and the Fixer: (Jul 28, 2022) What type of Microsoft Access developer are you? Being a robot is easy, being a technician is fun, but being a fixer is valuable.

Learning From Other Languages: (Nov 17, 2022) Even if you only write code professionally in a single language, learning the concepts and idioms of other languages will make you a better programmer.

Learning From Other Coding Styles: (Nov 18, 2022) Will learning multiple coding styles make you a better programmer? And, does it make sense to import those coding styles into your primary language?

Quick Tip

["Quick Tip" tag page]: Show all articles with the tag "Quick Tip" (including those where "Quick Tip" is a secondary tag).

Quick Tip: Emoji Lookup in Windows: (Oct 28, 2021) Looking for the fastest way to look up and insert emojis in Windows? This shortcut makes it quick and easy.

Quick Tip: Alt Codes in Windows: (Nov 6, 2021) Checkmarks, bulleted lists, section symbols, pi, daggers, copyrights, etc. Each of these symbols can be entered in Windows using an easy keyboard shortcut.

Inserting a Blank Line in the VBA Immediate Window: (Feb 3, 2022) Did you know you can insert a newline character in the Immediate Window without executing the current line of code?

Quick Tip: Force IntelliSense to Appear When Writing VBA: (Feb 18, 2022) Does the IntelliSense dropdown ever disappear when you're writing VBA? Do you backspace and re-type the dot to get it back? There's a better way.

Preventing Line Break After Debug.Print Statement: (Mar 1, 2022) Every time you call Debug.Print in VBA it outputs to a new line in the Immediate Window. ... But what if it didn't?!?!

Shortcut Key to Comment/Uncomment Blocks of Code in VBA: (Apr 18, 2022) You don't need 3rd-party tools to add keyboard shortcuts for commenting and uncommenting code blocks in VBA with this trick.

Quick Tip: Set Next Statement with Mouse: (May 5, 2022) Try this tip the next time you use the Edit & Continue feature when debugging. After more than 15 years of developing VBA, I'm still learning new things.

Adding References from VBA: (Aug 25, 2022) Did you ever wish you could bypass the Tools > References dialog entirely when adding references in Access? Automate the process with some simple VBA.

Micro-Efficiency: Duplicating Line(s) of Code in VBA: (Jan 17, 2023) With this technique, you'll save enough time to steal two and a half extra glances at your watch each day. Use it wisely.

How to Duplicate a Line of Code in VBA: (Jan 18, 2023) It's not quite a single shortcut key, but it's nearly as efficient.

Quick Tip: 4 Ways to Select the Bottom Control in a Stack: (Jan 30, 2023) There are many situations that call for two (or more) controls to be stacked on top of each other. In those situations, how does one select the bottom control?

Reader Challenge

["Reader Challenge" tag page]: Show all articles with the tag "Reader Challenge" (including those where "Reader Challenge" is a secondary tag).

Reader Challenge: Write a Formula to Calculate Gift Totals in "The Twelve Days of Christmas": (Dec 21, 2022) How many total gifts does one's true love deliver by the nth day of Christmas? It's a deceptively tricky problem to solve.

Calculating Gift Counts for "The Twelve Days of Christmas": Looping Edition: (Dec 22, 2022) In the first solution to my recent reader challenge, I use a loop to calculate the cumulative number of gifts given for each day of the "12 Days of Christmas."

Calculating Gift Counts for "The Twelve Days of Christmas": Recursion Edition: (Dec 23, 2022) In the second solution to my recent reader challenge, I use recursion to calculate the cumulative number of gifts given for each day of the "12 Days of Christmas."

Recap

["Recap" tag page]: Show all articles with the tag "Recap" (including those where "Recap" is a secondary tag).

Access Dev Team Progress Update: New Web Browser Control: (Nov 21, 2022) The Access team offers a sneak peek at the upcoming Edge-based browser control. Highlights include an estimated release date and future migration challenges.

Access Dev Team Progress Update: VBA Macro Code Signing: (Nov 25, 2022) The Access team offers a sneak peek at the new and improved VBA code signing experience. The feature is in public beta, and Microsoft is looking for testers.

Access Dev Team Progress Update: Dataverse Export Improvements: (Nov 28, 2022) The Access team provides an update on impending improvements to the Dataverse export feature.

Reports

["Reports" tag page]: Show all articles with the tag "Reports" (including those where "Reports" is a secondary tag).

Report Annoyances: (Mar 10, 2021) Five things I hate about the default behavior of DoCmd.OpenReport.

Previewing Reports: (Mar 11, 2021) That sound of your printer warming up means you forgot the acViewPreview flag again. You're better off avoiding DoCmd.OpenReport entirely.

OpenReport Shows Wrong Data: (Mar 12, 2021) Calling DoCmd.OpenReport on a report that's already open will not update the filtering on the report. You have to close it first.

The 'OpenReport' Action Was Canceled: (Mar 13, 2021) Does it annoy you that using the Report NoData event as Codd intended results in a runtime error? Because it annoys me.

Avoid the Cascading Maximize: (Mar 14, 2021) Prevent a full screen report from forcing the calling form to be maximized with this clever workaround.

Future Compatibility: (Mar 15, 2021) Use this trick to support future functionality while still getting your code to compile in older versions of Access.

PreviewReport Function: (Mar 16, 2021) This custom function is the simplest and safest way to preview reports in any Microsoft Access application.

Access Shape Drawing Reference: (Jul 5, 2022) With a bit of creativity, you can draw just about anything on an Access report. Everything you need to know is in Crystal Long's definitive guide.

Using Temp Tables as Report Record Sources: (Nov 4, 2022) If you're having trouble building a query to run a complex report, you may be better off populating a temp table and using that as your report's record source.

Ribbon

["Ribbon" tag page]: Show all articles with the tag "Ribbon" (including those where "Ribbon" is a secondary tag).

Icon Dimensions in the Office Ribbon: (Feb 4, 2022) Custom ribbon icons look sharpest when they are displayed at their native resolution.

Office Ribbon Development Resources: (Jun 22, 2022) Links to resources and ribbon builders for VBA developers who want to add a professional touch to their applications with custom ribbon interfaces.

XML Callbacks: Adding Functionality to the Office Ribbon: (Jun 23, 2022) To unlock the full potential of the Microsoft Office ribbon, you need to understand the role of callback functions. This quick intro will get you started.

Setting the Ribbon Name in Code: (Jun 28, 2022) You don't need to use the options dialog to set a custom ribbon for your Microsoft Access application.

Risk Management

["Risk Management" tag page]: Show all articles with the tag "Risk Management" (including those where "Risk Management" is a secondary tag).

Good. Better. Best.: (Dec 16, 2020) Take the test to see where your (or someone else's) Access application stands.

MS Access Risk Management: (Dec 20, 2020) Applying US Army risk management techniques to assess Microsoft Access application risk.

Proving the Concept with Access: (Dec 26, 2020) Committing to a major custom software development project is fraught with risk. Reduce that risk by prototyping in Access first.

Securing Your Data: (Feb 8, 2021) Relying on application-level security to protect your data would be like using guard rails to keep out your enemies.

Mail: An Allegory: (Feb 14, 2021) Behold, the world's greatest literary allegory since George Orwell penned "Animal Farm."

The Allegory Explained: (Feb 15, 2021) What does delivering mail have to do with writing software applications? I'm glad you asked.

Cowpathing with Microsoft Access: (Nov 26, 2021) How do you decide where to spend your software development dollars? Don't guess what your users need, let them show you with Access.

Signal vs. Noise

["Signal vs. Noise" tag page]: Show all articles with the tag "Signal vs. Noise" (including those where "Signal vs. Noise" is a secondary tag).

No Longer Set: (Oct 30, 2020) Signal is information that conveys meaning. Noise obscures that information. The key to writing good software is to maximize signal and minimize noise.

When Good Comments Go Bad: (Nov 10, 2020) Bad actors carry out disinformation campaigns to poison our discourse. But when we write code, sometimes we're the bad actors.

Signal vs. Noise: Error Handling: (Nov 20, 2020) To boost our signal to noise ratio, we can increase our lines of meaningful code or decrease the lines of boilerplate.

Signal vs. Noise: ShowPlan.out Edition: (Mar 16, 2022) Reading showplan.out files can be intimidating for new and experienced Access developers alike. This simple rule will help get you started.

Simple vs. Easy

["Simple vs. Easy" tag page]: Show all articles with the tag "Simple vs. Easy" (including those where "Simple vs. Easy" is a secondary tag).

Making the Complex Simple: Aquaponics Edition: (Sep 27, 2021) The most impressive software project any of my job applicants had written produced only a single, numeric output.

VBA: A Simple Programming Language: (Oct 14, 2022) VBA is a simple programming language. But is that really such a bad thing?

SQL

["SQL" tag page]: Show all articles with the tag "SQL" (including those where "SQL" is a secondary tag).

Finding Duplicate People by Date of Birth: (Nov 5, 2021) Let's explore the GROUP BY syntax with an exercise in identifying duplicate records in a Person table.

When to Use Right Outer Joins in SQL: (Dec 24, 2021) What's the difference between a RIGHT JOIN and a LEFT JOIN and why use one versus the other?

Fixing Circular References in Access Queries: (Feb 1, 2022) Did you get the error message, "Circular reference caused by alias 'MyField' in query definition's SELECT list"? Don't worry; it's an easy fix!

T-SQL ISNULL() vs. VBA IsNull() vs. Jet IS NULL vs. Access VBA Nz(): (Apr 15, 2022) How do I check thee for NULL? Let me count the ways.

SQL Gotcha: When an OUTER JOIN Accidentally Becomes an INNER JOIN: (Jun 2, 2022) If you apply a WHERE filter directly to the OUTER JOIN side of a query you will effectively turn it into an INNER JOIN.

SQL Azure

["SQL Azure" tag page]: Show all articles with the tag "SQL Azure" (including those where "SQL Azure" is a secondary tag).

SQL Azure for Access Developers: (Jan 17, 2022) If you've been thinking about migrating some of your Access application data to SQL Azure, this series of articles is for you.

SQL Azure Pricing Overview: (Jan 19, 2022) Figuring out SQL Azure pricing is straightforward. As in, it's just as pleasant as if you were to drive your car straight forward into a wall.

Creating Your First Azure SQL Database: The Basics: (Jan 21, 2022) Part 2 in my series on SQL Azure for Access Developers takes you step-by-step through the process of creating a new Azure SQL Database.

Configuring Firewall Settings on Azure SQL Server: (Jan 24, 2022) The simplest way to configure access to Azure SQL Server is via IP4-based firewall rules. We'll explore the pros and cons of a few different approaches.

SQL Server

["SQL Server" tag page]: Show all articles with the tag "SQL Server" (including those where "SQL Server" is a secondary tag).

Peeking Under the Hood: (Oct 15, 2020) Don't let these gotchas trip you up when using SQL Server as a backend for Microsoft Access.

All Hail Ola!: (Nov 12, 2020) If you're managing SQL Server and you're not using Ola Hallengren's scripts, then you're doing it wrong.

Cloning a SQL Server Database: (Nov 13, 2020) The fastest, simplest, and cheapest way to clone a SQL Server database for debugging or testing. Even works with SQL Server Express!

Tuning Access Query Performance: (Nov 15, 2020) The four best tools/techniques for tuning Access query performance: JetShowPlan, Process Monitor, TraceSQLMode, and SQL Profiler.

SQL Server Read-Only Mode: (Jan 1, 2021) Before running a final data migration, you want to ensure no further changes will be made to the old data. One way to do that is to set the database to read-only.

Working around the "Reboot Required" error when installing SQL Server: (Jan 3, 2021) A previous installation required a reboot... To proceed, [uninstall ODBC Driver 17,] restart your computer and then run Setup again.

Yes/No Fields in SQL Server: (Jan 4, 2021) The SQL Server equivalent of an Access Yes/No field is the "bit" data type. Or is it?

ODBC Driver 17 Prevents SSMS Install: (Jan 26, 2021) 3 steps to fix SSMS installation error 0x80070643: (1) Uninstall ODBC Driver 17; (2) Restart the machine; (3) Rerun the installer

Playing Telephone with SQL Server: (Jan 27, 2021) You won't believe how Access and SQL Server actually talk to each other. You're going to need to see this for yourself.

Role-based SQL Server Security: (Jan 30, 2021) There are many reasons to implement SQL Server roles even if you use Windows Authentication with Active Directory security groups.

Securing Access and SQL Server: (Feb 9, 2021) Wherein Anders Ebro demonstrates how easy it is to circumvent application-level security in an Access program.

Brent Ozar: Date Table Fan: (Mar 1, 2021) Brent Ozar, legendary SQL Server guru, makes his case for using a "Date Table." The video is all done in T-SQL, but the concepts apply equally to ACE backends.

Setting SQL Server Field Descriptions: (May 26, 2021) There are two basic ways to set field descriptions in SQL Server: via SSMS and T-SQL. Let's explore both.

UPSERT a Column Description in SQL Server: (May 27, 2021) Let's combine the stored procedures to Update and Insert SQL Server field comments into a single, all-encompassing solution.

Setting Field Descriptions on Linked SQL Server Tables: (May 28, 2021) What good are field descriptions in SQL Server if you don't see them in your Access front-end? Here's some code to bring those comments forward into Access.

Pushing Field Comments to SQL Server: (Jun 1, 2021) A VBA routine that takes field comments from a front-end linked table and pushes them to the corresponding back-end table in SQL Server.

Trust But Verify: (Sep 4, 2021) What Ronald Reagan's Words Can Teach Us About the Sample Code We Find on the Internet

Linking to SQL Server Date Fields from Microsoft Access: (Sep 18, 2021) I always avoided SQL Server's DATE type in favor of the DATETIME type's better compatibility with MS Access. A newer ODBC driver has me changing my mind.

Floating Point Arithmetic in VBA vs. SQL Server: (Sep 23, 2021) VBA and SQL Server do not perform floating-point operations the same way. Being aware of this difference could save you hours of frustration someday.

Unit Testing Tool for SQL Server: (Sep 28, 2021) This open-source database unit testing tool should help make test-driven database development easier to manage.

3 Gotchas of the SQL BETWEEN Statement: (Dec 10, 2021) The SQL BETWEEN statement produces very readable condition expressions. But developers of all skill levels can still get into trouble with it.

Quick Way to Troubleshoot SQL Server ADO Connections: (Dec 21, 2021) This simple trick provides you with plenty of clues when debugging a failed SQL Server connection on a user's computer.

How Access Reads Data From SQL Server: (Feb 16, 2022) How does Microsoft Access pull data from SQL Server? You'll be amazed when we pull back the curtain to expose how Access interacts with SQL Server.

SQL Server Connectors in 2022: (Feb 19, 2022) To get access to the latest features--especially security features--be sure you're using the latest ADO provider and ODBC driver for SQL Server.

Editing Data Directly in SSMS: (Mar 4, 2022) Query results in SQL Server Management Studio are read-only by default. Follow these steps to edit SQL Server table data directly inside SSMS.

Making Sense of SQLOUT.TXT: (Mar 9, 2022) You've enabled ODBC Trace SQL Mode and created a sqlout.txt file. But do you know what to do with it now? Let's explore.

Save $3,500 by Creating Scheduled Backups Using SQL Server Express: (Apr 6, 2022) You don't need to spend big bucks to get automated database backups with SQL Server. This simple step-by-step process is nearly foolproof.

IIF ... IS NULL vs. Nz(): Testing a Hypothesis: (May 13, 2022) Which is better in a WHERE clause: IIf...Is Null or Nz()? Or is there a third option that's better than both of those?

Advanced Server-Side SQL Server Query Troubleshooting: (May 16, 2022) The XEvent Profiler in SSMS is a powerful troubleshooting tool, but what happens when the standard sessions are not enough? We need to customize...

How to Install SQL Server on a Read-Only Domain Controller (RODC): (May 18, 2022) The official Microsoft documentation says it's not possible, but with a little ingenuity and poor judgment, we can get SQL Server to run on an RODC.

Deleting a Large Number of Records in SQL Server: (May 24, 2022) Let's explore four options--two bad and two good--for deleting one million or more records from a single SQL Server table.

HOW TO: Automate Batch Deletion of SQL Server Records: (May 25, 2022) Using a single DELETE statement to remove 20 million+ records from SQL Server is a bad idea. Here's a better approach.

Epoch Differences Between VBA and SQL Server: (Dec 16, 2022) Do you have unexplained dates of December 30, 1899 in your SQL Server database? VBA's epoch (i.e., zero date) could be the culprit.

5 Tips for Making Changes on Live SQL Server Databases: (Jan 12, 2023) Making database changes on production? These 5 tips will make one of the most dangerous programming activities a little bit safer.

Subforms

["Subforms" tag page]: Show all articles with the tag "Subforms" (including those where "Subforms" is a secondary tag).

Technical Debt

["Technical Debt" tag page]: Show all articles with the tag "Technical Debt" (including those where "Technical Debt" is a secondary tag).

Old Code Left in Place: (Jan 17, 2021) What's the harm in leaving old code in place? It's not like it costs us anything. ... Or does it?

Old Fields Left in Place: (Jan 18, 2021) Leaving old fields in place is even worse than leaving old code. Instead of runtime errors, you'll end up with harder-to-detect data errors.

Denormalized Database Tables: (Jan 19, 2021) Normalize your database tables to avoid technical debt.

Coding Before Designing: (Jan 20, 2021) Weeks of coding can save hours of planning.

Overuse of Global State: (Jan 21, 2021) You wouldn't control the water temperature in your entire house from a single location. Why would you write your code that way?

Overly Clever Code: (Jan 22, 2021) Keep It Simple, Stupid

Storing Local Table Data in a Front-End Access Application: (Oct 26, 2021) If you're thinking about storing local data in your front-end Access application, make sure it follows these 4 ground rules.

TempVars

["TempVars" tag page]: Show all articles with the tag "TempVars" (including those where "TempVars" is a secondary tag).

A Safer Way to Use TempVars: (Sep 20, 2022) The TempVars object is an intriguing alternative to traditional global variables, but it has some shortcomings. Here's one way to work around them.

TV: The TempVars Class Module: (Sep 21, 2022) A TempVars class module that provides visibility, type safety, IntelliSense, and compile-time typo checks.

Beware TempVars in Queries: (Sep 22, 2022) Many Access users rave about using TempVars with queries. I decided to see what the hype was about. What I found shocked me.

Safely Using TempVars in Queries: (Sep 23, 2022) Calling TempVars directly from a query can cause issues. Instead, use this simple wrapper function to save yourself some potential headaches.

Populating a List Box with the TempVars Collection: (Sep 27, 2022) If you use TempVars in your Microsoft Access applications, this handy function will bring visibility to the contents of that collection.

tblTempVar: Creating and Populating a Table of TempVars: (Sep 28, 2022) These three simple procedures: (1) create, (2) populate, and (3) create/delete + populate a local table with the contents of the TempVars collection.

GenerateTVClass(): Auto-Create a TempVars Class Module: (Oct 21, 2022) The culmination of my TempVars series, this article shows you how to generate a TempVars class module from a local table.

Testing

["Testing" tag page]: Show all articles with the tag "Testing" (including those where "Testing" is a secondary tag).

Python-inspired Doc Tests in VBA: (Sep 21, 2020) Doc tests are not a replacement for unit or integration testing. But they do provide the best return on investment (ROI) of any type of test, mostly because the effort to write them is near zero.

VBA Doc Tests: Advanced Features: (Sep 22, 2020) Let's take our doc tests to the next level. I'll show you how to use my custom DocTests function to test classes, private functions, and error conditions.

Text-To-Speech

["Text-To-Speech" tag page]: Show all articles with the tag "Text-To-Speech" (including those where "Text-To-Speech" is a secondary tag).

Reading Text Aloud in Microsoft Access: (Jan 7, 2022) Want a quick way to get started with Text-to-Speech in your VBA application? This 4-line method gets the job done and requires no references!

Tools

["Tools" tag page]: Show all articles with the tag "Tools" (including those where "Tools" is a secondary tag).

My Favorite Things: (Sep 24, 2020) Here is a list of my favorite utilities, add-ins, OCX controls, and applications that I use when developing Microsoft Access applications.

21st Century Visual Basic: (Dec 27, 2020) Microsoft stopped supporting VB6 in 2008. Here are some modern options for migrating those old apps or developing new ones in 2020 and beyond.

No Longer Set: (Jan 9, 2021) Tools and techniques for creating installation packages for Access applications and automatically updating front-end program files.

Bad Words in Access: (Jan 31, 2021) Note, Caption, Format, Pages, Sequence. All reasonable-sounding field names, but all should be avoided.

vbWatchdog Webinar: (Feb 10, 2021) Peter Cole of ThemeMyDatabase.co.uk presents a demonstration of vbWatchdog in action. Come for the info, stay for the discount code.

Everything You Need to Find Files: (Feb 12, 2021) Or, should I say, You Need *Everything* to Find Files.

Hiding Shortcuts in Everything: (Feb 16, 2021) Here's a quick tip from Tom Wickerath for hiding shortcut files from your Everything file search results.

Rainbow CSV: (Mar 30, 2021) If you work with delimited text files of any kind, you need to be using this VS Code extension.

KnowledgeBase Mausoleum: (Mar 31, 2021) Looking for that long-lost KnowledgeBase article from 2003 but only finding a 404 error? This website brings dead KB articles back to life.

Enable Live Transcription in MS Teams Meetings: (Apr 20, 2021) Is the "Start transcription" option missing from your Teams menu? Is the "Join" button missing from your calendar entry? Maybe I can help (but probably not).

AccessUI - Data Source Manager: (May 21, 2021) Tired of dealing with the limitations and poor UI of Access's built-in linked table manager? Try this FREE improved version from Kevin Bell.

Commento vs. Cove Comments: (Jun 21, 2021) Commento and Cove are both third-party comment hosting platforms. Which one works best with Ghost CMS?

Customizing the VBA Debug Toolbar: (Jul 5, 2021) There are some very handy commands that VBA does not expose by default. Here's a step-by-step guide to customizing the Debug toolbar in VBA.

3 Ways to Run the Best Low-Level Windows Debugging Tool: (Jul 20, 2021) A surprising number of thorny Access performance issues can be resolved with this venerable tool. Here's how to get started with Process Monitor.

RegEx101.com: (Aug 2, 2021) Writing and reading regular expressions is like speaking a foreign language. Think of regex101.com like Google Translate for regexes.

3 Tools to Take and Manage Screenshots: (Oct 16, 2021) A picture is worth a thousand words. Here are three tools that I use to make the process of taking screenshots as smooth as possible.

Keybase: A Simple and Secure Way to Communicate: (Oct 27, 2021) Whenever I need to share sensitive information with my team--such as passwords or private keys--I use Keybase for peace of mind.

Advanced Data Generator 4: First Look: (Dec 9, 2021) Looking to generate lots of test data in your backend Access databases? Advanced Data Generator 4 may be exactly what you are looking for.

Application Environment Inheritance: (Jan 12, 2022) Understanding how applications inherit environment settings from one another can shed light on some otherwise puzzling situations.

Setting a Common Path to Sharepoint Site Folders on Multiple Devices: (Jan 25, 2022) This quick tip will help you create consistent development environments across multiple devices and users.

Creating a Shortcut to an Environment Variable Path: (Jan 27, 2022) If you rely on OneDrive or SharePoint to collaborate on files with your team, this tip will help you provide a uniform way to access data across all devices.

Simple Fix for Missing DBF Support in Access 2013: (Jan 29, 2022) Quick fix installers that restore Access 2013 DBF support *PLUS* the techniques I used to build the installers using 7-Zip and Inno Setup.

Using ProcMon to Troubleshoot Registry Calls: (Feb 10, 2022) Finding the correct registry keys for JetShowPlan and ODBC TraceSqlMode can be tricky. Let ProcMon take the guesswork out of the process.

3 Ways to Find Showplan.out: (Feb 11, 2022) Finding Jet ShowPlan's showplan.out file can be deceptively difficult. Here are three approaches to make it easy. At least one is guaranteed to work.

3 Ways to Find sqlout.txt: (Mar 2, 2022) Finding ODBC TraceSQLMode's sqlout.txt file can be deceptively difficult. Here are three approaches to make it easy. At least one is guaranteed to work.

3 Free Options for Managing Linked Tables in Access: (May 17, 2022) The original linked table manager was a terrible tool. Let's look at three better options for today's Microsoft Access developers.

Changing Internet Explorer Options in IE Mode of Microsoft Edge: (Jul 19, 2022) Did you try to change Internet Explorer options from IE Mode in Edge only to realize that you can't get to them? Luckily, there's an easy workaround.

Access Database Right-Click Context Menu Creator: (Jul 25, 2022) Wouldn't it be great to right-click an Access file to compact or decompile it? With Daniel Pineault's awesome tool, you can!

Automatically Link to Your Bug Database from TortoiseHg: (Aug 17, 2022) Everyone's favorite Windows Mercurial software includes a killer feature that is criminally underused.

Connecting to GitHub from TortoiseHg Using SSH Keys: (Aug 18, 2022) Step-by-step instructions to set up a completely seamless integration between TortoiseHg and GitHub. No passwords. No Pageant. No friction of any kind.

AccessImagine: ActiveX Picture Control for Access: (Aug 24, 2022) If you are building an image-rich data application with Microsoft Access, you can save yourself a lot of development time with a third-party tool like AccessImagine.

ActiveX Controls: Love 'Em or Hate 'Em?: (Aug 29, 2022) I always avoid ActiveX controls in my Access applications. Except when I can't. Or don't want to. It's complicated...

Checking Version Compatibility with NetOffice: (Nov 1, 2022) Take advantage of the open-source NetOffice project on GitHub to look up version compatibility for the Access/Office/Word/Excel object models.

Using FreeMind as a Schema Development Tool: (Dec 28, 2022) In the early stages of planning a database design, I prefer a tool that lets me capture my thoughts as they flow without getting in the way. FreeMind is that tool.

twinBASIC

["twinBASIC" tag page]: Show all articles with the tag "twinBASIC" (including those where "twinBASIC" is a secondary tag).

The TwinBasic IDE: VS Code: (Apr 6, 2021) Many a fledgling programming language has died an early, quiet death at the hands of poor tooling. TwinBasic looks to avoid that fate with robust VS Code support.

Writing Code in TwinBasic: Part 1: (Apr 7, 2021) Let's explore three features of the code writing experience in TwinBasic: IntelliSense, Go to definition, and Semantic Highlighting.

Writing Code in TwinBasic: Part 2: (Apr 8, 2021) Let's explore three more features of the code writing experience in TwinBasic: Code folding, Inline parameter hints, and Outline view.

Debugging Code in twinBASIC: (Apr 9, 2021) Experienced developers know that they spend more time debugging code than writing it. Luckily, twinBASIC has some capable debugging tools.

Creating a twinBASIC ActiveX DLL: (Apr 10, 2021) Okay, twinBASIC. It's time to make yourself useful.

New Syntax in twinBASIC: Part 1: (Apr 11, 2021) Let's cover some new syntax in twinBASIC, including "AndAlso/OrElse"; the ternary If() operator; and "Continue For" and its cousins.

New Syntax in twinBASIC: Part 2: (Apr 12, 2021) Let's cover some more new syntax in twinBASIC, including parameterized class constructors, method overloading, and return syntax for functions.

Docstrings in twinBASIC: (Apr 13, 2021) twinBASIC takes a page out of the RubberduckVBA book, using code comment "annotations" to generate real-time, IntelliSense-integrated documentation.

New Syntax in twinBASIC: Part 3: (Apr 14, 2021) There's even more new syntax in twinBASIC, including the IsNot operator, initializing on declare, and augmented assignment operators.

twinBASIC's 100% Compatibility Goal: (Apr 16, 2021) The difference between 100% compatible and 99% compatible is way more than 1%.

Preview Limitations in twinBASIC: (Apr 17, 2021) CAUTION! twinBASIC is a work-in-progress. To avoid frustration, learn what's not working *before* you start playing with it.

Generic Objects in twinBASIC: (Apr 18, 2021) twinBASIC supports generic objects! Let's dig into the details with a practical example.

twinBASIC Runtime Requirements: (Apr 19, 2021) The title's a little misleading. SPOILER ALERT! There are no runtime requirements for twinBASIC.

Multithreading in twinBASIC: (Apr 21, 2021) We may not have the syntax to write multi-threaded code yet, but that can't stop us from creating multiple threads in the twinBASIC Debug Console.

DevCon 2021: (Apr 23, 2021) Links and resources from my talk today at Access DevCon Vienna 2021, twinBASIC: The New Kid on the Block.

Pseudo-Command Line Args in twinBASIC: (May 22, 2021) I couldn't figure out how to pass command line arguments to a twinBASIC console application. So I improvised a solution.

twinBASIC: Setting Cmd Line Args in Debug Mode: (May 24, 2021) The VB6 Command$() function returns command line arguments in twinBASIC. But, for now, we still need a workaround to set cmd line args while debugging.

How to Use Version Control with twinBASIC: (Jun 24, 2021) You can now extract the embedded text files from .twinproj containers for use in version control. I wrote a batch file to make the process even easier.

HOW TO: Create a Custom ActiveX Control with twinBASIC: (Apr 23, 2022) Did you ever wish you could build a custom control for Microsoft Access forms and reports? With twinBASIC, that's a 15-minute project.

HOW TO: Create a Tool Window in the VBIDE with twinBASIC: (Apr 26, 2022) Move over Rubberduck VBA and MZ-Tools. The next great VBE addin is going to be built with twinBASIC. Here are step-by-step instructions to get you started.

HOW TO: Creating an Office COM Add-in with twinBASIC: (Jun 13, 2022) Ever wish you could turn your VBA code into a COM add-in that would run in 32- AND 64-bit Office applications? It's easier than ever with twinBASIC.

HOW TO: Creating a Standard (non-ActiveX) DLL with twinBASIC: (Jun 16, 2022) With twinBASIC, you no longer need C++ to build a standard DLL. Call high-performance code from VBA without needing the Windows registry.

twinBASIC Weekly Updates: (Jul 18, 2022) The twinBASIC weekly updates now have their own dedicated tag on nolongerset.com, making it easier to find the other twinBASIC articles.

HOW TO: Install twinBASIC: (Aug 11, 2022) The latest step-by-step instructions for installing twinBASIC (aka, Visual Basic 8).

HOW TO: Handle Excel Events in a twinBASIC COM Addin: (Aug 23, 2022) You can now use twinBASIC to create a COM add-in for Excel that handles Excel Application events like NewWorkbook and WorkbookOpen.

twinBASIC Weekly Update

["twinBASIC Weekly Update" tag page]: Show all articles with the tag "twinBASIC Weekly Update" (including those where "twinBASIC Weekly Update" is a secondary tag).

twinBASIC Update: May 2, 2021: (May 2, 2021) Highlights include C-style block comments, support for additional Rubberduck annotations, and With blocks for UDTs.

twinBASIC Update: May 9, 2021: (May 9, 2021) Highlights include support for a new Attribute syntax, ActiveX DLL registration via regsvr32, and PredeclaredID for twinBASIC classes.

twinBASIC Update: May 16, 2021: (May 16, 2021) Highlights include stability improvements for the twinBASIC compiler and the YouTube release of my hourlong twinBASIC presentation at DevCon Vienna.

twinBASIC Update: May 23, 2021: (May 23, 2021) Highlights include passing (pseudo-)command-line arguments to a twinBASIC console app and an update from Wayne on the project's progress.

twinBASIC Update: May 30, 2021: (May 30, 2021) Highlights include improved compiler stability, making the Optional keyword optional, and setting command-line arguments for debugging.

twinBASIC Update: June 6, 2021: (Jun 6, 2021) Highlights include Mid statement support, DefType support, multiple bug fixes, and a (sort of) announcement regarding unit testing support.

twinBASIC Update: June 13, 2021: (Jun 13, 2021) Highlights include Like statement support and a new VS Code command to create new project files (no more downloading .zip files from twinbasic.com!).

twinBASIC Update: June 20, 2021: (Jun 20, 2021) Highlights include custom events in twinBASIC classes, full Debug.Print syntax support, and an experimental code prettifier.

twinBASIC Update: June 27, 2021: (Jun 27, 2021) Highlights include support for external version control, the official launch of the code prettifier, and support for resources and visual styles via manifest files.

twinBASIC Update: July 4, 2021: (Jul 4, 2021) Highlights include support for EXE/DLL embedded resources plus *LOTS* of code writing experience improvements, like rename refactoring, auto-indent, etc.

twinBASIC Update: July 11, 2021: (Jul 11, 2021) Highlights include a sneak peek at the yet-to-be-released form editor, a teaser about possible control inheritance, and a future option for version control.

twinBASIC Update: July 18, 2021: (Jul 18, 2021) Highlights include continued work on the GUI plus future support for web forms and IntelliSense in the Debug Console.

twinBASIC Update: July 25, 2021: (Jul 25, 2021) Highlights include unique icon colors for each code file type, plus Standard vs. Professional vs. Ultimate editions, pricing, pre-orders, and early-bird discounts.

twinBASIC Update: August 1, 2021: (Aug 1, 2021) Highlights include VSCode CodeLens support, compiler warnings, VB_GlobalNameSpace support, and twinBASIC's debut on stackoverflow.

twinBASIC Update: August 8, 2021: (Aug 8, 2021) Highlights include a revamped references list UX, a 100%-twinBASIC-compatible Printers object replacement, and news on unit testing and documentation.

twinBASIC Update: August 15, 2021: (Aug 15, 2021) Highlights include IntelliSense improvements, a 12-month twinBASIC roadmap, and a pure Win32 API GUI application written in twinBASIC.

twinBASIC Update: August 22, 2021: (Aug 22, 2021) Highlights include a sneak-peek at the forthcoming integrated unit testing framework, App.ThreadID, App.hInstance, and MSVBVM60.dll redirections.

twinBASIC Update: August 29, 2021: (Aug 29, 2021) Highlights include Unit Testing support, conditional breakpoints, the Nz() function, and various IntelliSense improvements.

twinBASIC Update: September 5, 2021: (Sep 5, 2021) Highlights include IntelliSense in the Debug Console, unit testing improvements, and the addition of #Error and #Warning directives.

twinBASIC Update: September 12, 2021: (Sep 12, 2021) Highlights include VS Code Extensibility, RGB extraction functions, dropping Finalize(), and a discussion regarding potential typedef support.

twinBASIC Update: September 19, 2021: (Sep 19, 2021) Highlights include discussions around block scoping and a planned ObjRefCount() function.

twinBASIC Update: September 26, 2021: (Sep 26, 2021) Highlights include a sneak peek at building custom form controls, the related dynamic property sheet, and a bunch of screenshots teasing the upcoming features.

twinBASIC Update: October 3, 2021: (Oct 3, 2021) Highlights include a glimpse into the possible GUI release timeline and a discussion about data binding with twinBASIC forms.

twinBASIC Update: October 10, 2021: (Oct 10, 2021) Highlights include an extended preview of the yet-to-be-released form designer and a spirited discussion about whether to fork VS Code to create a dedicated tB IDE.

twinBASIC Update: October 17, 2021: (Oct 17, 2021) Highlights include the alpha release of CustomControls, a twinBASIC wiki, and a revived discussion around "Quirks Mode" in twinBASIC.

twinBASIC Update: October 24, 2021: (Oct 24, 2021) Highlights include the addition of 4 new custom control events, ElementTabStop/Index properties, and a Spanish presentation on twinBASIC.

twinBASIC Update: October 31, 2021: (Oct 31, 2021) Highlights include initial support for a Clipboard object, a new custom control sample (Wayne's TextBox), and support for Return as an alias for Exit Sub.

twinBASIC Update: November 7, 2021: (Nov 7, 2021) Highlights include our first look at a working twinBASIC form, the early makings of inheritance support, and the promise of custom ActiveX control development.

twinBASIC Update: November 14, 2021: (Nov 14, 2021) Highlights include temporary removal of the license key requirement for CustomControls and partial inheritance support using Implements ... Via.

twinBASIC Update: November 21, 2021: (Nov 21, 2021) Highlights include 64-bit compilation support (no license required!) and a discussion about early binding and reference handling.

twinBASIC Update: November 28, 2021: (Nov 28, 2021) Highlights include the first major release of file handling statements and functions in twinBASIC, along with talk of providing a tB license to the Rubberduck project.

twinBASIC Update: December 5, 2021: (Dec 5, 2021) Highlights include the implementation of additional File System features, improved performance for Split and Replace, and a discussion about universal binaries.

twinBASIC Update: December 12, 2021: (Dec 12, 2021) Highlights include the File I/O system reaching feature-complete status, an updated twinBASIC roadmap, and experimental text encoding support.

twinBASIC Update: December 19, 2021: (Dec 19, 2021) Highlights include support for importing VB6 project files (*.vbp), new MsgBox options, and a spirited discussion about what tB's design priorities should be.

twinBASIC Update: December 26, 2021: (Dec 26, 2021) Highlights include several improvements to the COM references list, a fix for the hidden dialog windows issue, and many discussions about possible tB features.

twinBASIC Update: January 2, 2022: (Jan 2, 2022) Highlights include a feature to generate missing implementations, minor improvements to the Reference List UX, and some spirited debates.

twinBASIC Update: January 9, 2022: (Jan 9, 2022) Highlights include error messages that now match VBx, a twinBASIC Discord server, and a teaser about twinBASIC's potential as a VBA replacement.

twinBASIC Update: January 16, 2022: (Jan 16, 2022) Highlights include the CompileIf attribute and IsObject function for generics, an experimental package manager, and 10 Guiding Principles of twinBASIC.

twinBASIC Update: January 23, 2022: (Jan 23, 2022) Highlights include the introduction of TWINPACKs and the TWINSERV package manager, IntelliSense improvements, and easier reporting of twinBASIC bugs.

twinBASIC Update: January 30, 2022: (Jan 30, 2022) Highlights include a sample project demonstrating the WaynesGrid control and a timeline update for the release of (some) native Win32 controls.

twinBASIC Update: February 6, 2022: (Feb 6, 2022) Highlights include the milestone release of WinForms functionality, control inheritance, ReadOnly class properties, and twinPACK updating documentation.

twinBASIC Update: February 13, 2022: (Feb 13, 2022) Highlights include a new Settings filter bar and WinForms Controls Package updates included by default with future twinBASIC extension updates.

twinBASIC Update: February 20, 2022: (Feb 20, 2022) Highlights include checkbox-style list boxes, native Winforms progress bar and image controls, and an option to align controls to grid in the form designer.

twinBASIC Update: February 27, 2022: (Feb 27, 2022) Highlights include multiple form designer improvements and a *BIG* announcement about the future of the twinBASIC IDE.

twinBASIC Update: March 6, 2022: (Mar 6, 2022) Highlights include a sneak peek at the new twinBASIC IDE (currently under development) and a brief comparison between RAD Basic and twinBASIC.

twinBASIC Update: March 13, 2022: (Mar 13, 2022) Highlights include another sneak peek of the upcoming twinBASIC IDE and a special announcement regarding Access DevCon Vienna 2022.

twinBASIC Update: March 20, 2022: (Mar 20, 2022) Highlights include a cryptic update on the new IDE's release date and a possible twinBASIC solution to the oft-delayed Access modern browser control.

twinBASIC Update: March 27, 2022: (Mar 27, 2022) Highlights include a release date for the twinBASIC IDE and plans to open-source the IDE's source code.

twinBASIC Update: April 3, 2022: (Apr 3, 2022) Highlights include the release of the new IDE and an announcement about twinBASIC's role at the upcoming Access DevCon Vienna conference.

twinBASIC Update: April 10, 2022: (Apr 10, 2022) Highlights include 7 (!) new releases of the twinBASIC IDE and twinBASIC solving a difficult problem for a popular MS Access open-source addin.

twinBASIC Update: April 16, 2022: (Apr 16, 2022) Highlights include multiple debug console performance improvements and a workaround for antivirus software flagging twinBASIC as potential malware.

twinBASIC Update: April 24, 2022: (Apr 24, 2022) Highlights include updated samples for building custom VBIDE tool windows and custom ActiveX controls that you can drop on Access forms and reports.

twinBASIC Update: May 1, 2022: (May 1, 2022) Highlights include Set Next Statement support, new code samples and templates, a roadmap update, and a 7-Zip VBA library written in twinBASIC.

twinBASIC Update: May 8, 2022: (May 8, 2022) Highlights include version control-friendly improvements to the new IDE, an IDE Font Size setting, and a milestone for another VBx successor language, RAD Basic.

twinBASIC Update: May 15, 2022: (May 15, 2022) Highlights include a modern browser control for Microsoft Access (yes, you read that right) and a spirited discussion regarding attribute syntax.

twinBASIC Update: May 22, 2022: (May 22, 2022) Highlights include the beginnings of a Screen object, an updated Attribute syntax, and a reimagined ending to a Disney classic (yes, it's a bit off-topic).

twinBASIC Update: May 29, 2022: (May 29, 2022) Highlights include new build features, a good Exit Code discussion, and a multi-threaded twinBASIC proof of concept from Ben Clothier.

twinBASIC Update: June 5, 2022: (Jun 5, 2022) Includes a sneak peek of the upcoming ActiveX Control Extender support in twinBASIC.

twinBASIC Update: June 12, 2022: (Jun 12, 2022) Highlights include ActiveX control support on twinBASIC forms and a discussion about the (accidental?) interface constructor language feature.

twinBASIC Update: June 19, 2022: (Jun 19, 2022) Highlights include improved support for 3rd-party ActiveX controls, a new location for tB IDE releases, and a discussion about where to put non-visual controls.

twinBASIC Update: June 26, 2022: (Jun 26, 2022) Highlights include container support, IDE bug fixes, and a modest request for a complete backward-compatible rewrite of MS Access in twinBASIC.

twinBASIC Update: July 3, 2022: (Jul 3, 2022) Highlights include added support for the VB6 `End` statement, shape controls, and double-click to change property values in the IDE.

twinBASIC Update: July 10, 2022: (Jul 10, 2022) Highlights include new shape controls, code-signed twinBASIC IDE and compiler executables, and twinBASIC's first appearance on HackerNews.

twinBASIC Update: July 17, 2022: (Jul 17, 2022) Highlights include double-click to change form/control properties in the IDE, support for the Form.Show Modal argument, and a discussion about On Error Resume Next.

twinBASIC Update: July 24, 2022: (Jul 24, 2022) Highlights include implementation of the form Controls collection, initial publication of the twinBASIC Guiding Principles, and the potential to write device drivers with tB.

twinBASIC Update: July 31, 2022: (Jul 31, 2022) Highlights include improved support for building device drivers, initial support for keyboard menu navigation, and a milestone for the twinBASIC project.

twinBASIC Update: August 7, 2022: (Aug 7, 2022) Highlights include a major compiler refactor to help reduce compiler memory usage and proposed support for multiple built-in rounding methods.

twinBASIC Update: August 14, 2022: (Aug 14, 2022) Highlights include IDE memory optimizations, build size reductions, and a discussion about a potential extensibility library for the IDE.

twinBASIC Update: August 21, 2022: (Aug 21, 2022) Highlights include IDE improvements, support for Excel events in COM addins, and a kernel-mode driver written in twinBASIC (yes, really).

twinBASIC Update: August 28, 2022: (Aug 28, 2022) Highlights include improvements to code selector boxes in the IDE, IntelliSense improvements, and better support for "kernel mode" (i.e., device drivers).

twinBASIC Update: September 4, 2022: (Sep 4, 2022) Highlights include new IDE shortcut keys, an awesome new IDE History panel, and a project from fafalone that showcases twinBASIC's interface definition feature.

twinBASIC Update: September 11, 2022: (Sep 11, 2022) Highlights include 4 new form controls (TreeView, DriveListBox, DirListBox, FileListBox), an impromptu Q&A with Wayne, and WinNativeForms source.

twinBASIC Update: September 18, 2022: (Sep 18, 2022) Highlights include the initial implementation of a PictureBox control and a custom Windows Event Viewer written in twinBASIC.

twinBASIC Update: September 25, 2022: (Sep 25, 2022) Highlights include long-awaited VB6 form import support (experimental) and a community-led GitHub project to provide official documentation for twinBASIC.

twinBASIC Update: October 2, 2022: (Oct 2, 2022) Highlights include a pile of new form and control properties, a form menu designer, visual tab stop indicators in design view, and a new twinBASIC LinkedIn group.

twinBASIC Update: October 9, 2022: (Oct 9, 2022) Highlights include support for control and menu arrays, a Type Library Viewer (Object Browser equivalent), and a video interview with twinBASIC creator Wayne Phillips.

twinBASIC Update: October 16, 2022: (Oct 16, 2022) Highlights include two new ways to open the twinBASIC IDE (via .twinproj files and Windows shortcuts), better performance for IDE panels, and more GUI progress.

twinBASIC Update: October 23, 2022: (Oct 23, 2022) Highlights include many IDE improvements, better support for high-performance code, and a sample Task Dialog project from fafalone.

twinBASIC Update: October 30, 2022: (Oct 30, 2022) Highlights include better PNG handling, improvements to the custom menu builder, and support for a NumbersOnly textbox property.

twinBASIC Update: November 6, 2022: (Nov 6, 2022) Highlights include native CoClass support and a TWINPACK package from fafalone with definitions for all the standard common controls.

twinBASIC Update: November 13, 2022: (Nov 13, 2022) Highlights include drag and drop support, an innovative IDE feature known as "Type Hints", and a proof-of-concept twinBASIC multithreading project.

twinBASIC Update: November 20, 2022: (Nov 20, 2022) Highlights include several bug fixes, a new method to clear the debug console, and a discussion about the difference between Drag and OLEDrag methods.

twinBASIC Update: November 27, 2022: (Nov 27, 2022) Highlights include support for graphical buttons, OLE drag and drop, and some exciting news about the upcoming release of Rubberduck VBA 3.0.

twinBASIC Update: December 4, 2022: (Dec 4, 2022) Highlights include initial support for importing VB6 forms with ActiveX controls, GoSub syntax support, and context-sensitive custom help support.

twinBASIC Update: December 11, 2022: (Dec 11, 2022) Updates include a version 1 release date, twinBASIC roadmap update, and several bug fixes.

twinBASIC Update: December 18, 2022: (Dec 18, 2022) Highlights include initial support for user controls, a new list view option for the form designer toolbox, and another sample twinBASIC project from fafalone.

twinBASIC Update: December 26, 2022: (Dec 26, 2022) Highlights include the smallest bug report in twinBASIC history, a repository of twinBASIC sample projects, and a tB-based VBA DocTest runner from Ben Clothier.

twinBASIC Update: January 1, 2023: (Jan 1, 2023) Highlights include a redesigned form preview button, a file watcher sample application from fafalone, and a holiday message from Wayne Phillips.

twinBASIC Update: January 8, 2023: (Jan 8, 2023) Highlights include .vbp UserControl import support, a twinBASIC VBCCR demo project, live variable hover tips in the IDE, and a discussion of post-v1 breaking changes.

twinBASIC Update: January 15, 2023: (Jan 15, 2023) Highlights include a new VBCCR-based GUI project type, a VBCCR TWINSERV package, and a discussion about support for block-level scope in twinBASIC.

twinBASIC Update: January 29, 2023: (Jan 29, 2023) Highlights include an updated roadmap and v1 release date, new UserControl events support, and several new tB sample projects from fafalone and Ben Clothier.

twinBASIC Update: February 5, 2023: (Feb 5, 2023) Highlights include a major rewrite of the ActiveX implementation, updates to two community projects, and a discussion about the business side of twinBASIC.

Under 100

["Under 100" tag page]: Show all articles with the tag "Under 100" (including those where "Under 100" is a secondary tag).

Much Ado About Little: The #Under100 Series: (Aug 24, 2021) Brevity is the soul of wit.

What is a Database Index?: (Aug 25, 2021) The concept of database indexes explained in under 100 words. #Under100

What is a Covering Index?: (Aug 26, 2021) The concept of "covering indexes" explained in under 100 words. #Under100

What is Referential Integrity?: (Sep 29, 2021) The concept of referential integrity explained in under 100 words.

What is a Call Stack?: (Nov 3, 2021) The concept of a call stack explained in under 100 words. #Under100

What is COM?: (Mar 5, 2022) The concept of COM explained in under 100 words. #Under100

What is Database Normalization?: (Oct 20, 2022) The concept of database normalization explained in under 100 words. #Under100

What is rowversion in SQL Server?: (Oct 31, 2022) The concept of SQL Server's rowversion data type explained in under 100 words. #Under100

What does RBAR mean?: (Nov 3, 2022) The concept of RBAR explained in under 100 words. #Under100

Unicode

["Unicode" tag page]: Show all articles with the tag "Unicode" (including those where "Unicode" is a secondary tag).

Unicode MsgBox Revisited: (Sep 15, 2022) A small improvement to my Unicode-friendly MsgBox and a handy trick for avoiding compile errors across Word/Excel/Access/etc.

UX

["UX" tag page]: Show all articles with the tag "UX" (including those where "UX" is a secondary tag).

6 Reasons Why I No Longer Use Bound Forms to Add Records in Microsoft Access: (Jun 29, 2021) Just because something can serve two purposes, doesn't mean it should. (Reason number four can be a real game-changer.)

Simple vs. Easy: (Sep 24, 2021) It's not easy to build simple software. These 4 simple tips will make the process easier.

4 Approaches to Storing and Displaying Time Spans in Microsoft Access: (Apr 12, 2022) As an Access developer, how do you store and display time spans like "3 days" or "2 weeks"? Let's cover the pros and cons of four different approaches.

VBA

["VBA" tag page]: Show all articles with the tag "VBA" (including those where "VBA" is a secondary tag).

Avoiding Overflow Errors When Defining Calculated Constants: (Mar 10, 2022) Overflow errors are usually straightforward. But what about when you get an overflow assigning a value of 1 to a Long integer?

Philipp Stiefel on VBA Compilation: (Mar 24, 2022) Is VBA an interpreted language? Or a compiled language? Or something in between. Philipp Stiefel shines light on the topic for us.

Static Functions and Subs: (Apr 20, 2022) After fifteen years of writing VBA, I'm still learning new features of the language. Even if they're not particularly useful features...

Namespaces in VBA: (Sep 19, 2022) VBA may not have the same level of formal support for namespaces as VB.NET, but with a little creativity, we can realize the same benefits in other ways.

3 Ways to Generate Temporary File Names in VBA: (Oct 4, 2022) Here are three options for generating temporary file names in VBA. Which is best? As with many programming questions, the answer is, "It depends."

Dollar Signs at the End of VBA Functions: (Nov 10, 2022) What's the difference between Left() and Left$()? Why would you use one or the other? And what do *I* do, personally?

Avoiding the "Invalid in Immediate Pane" Error: (Dec 30, 2022) Sometimes, using the colon character to combine statements in the immediate window results in an "Invalid in immediate pane" error. Here's why and how to fix it.

Scope vs. Extent in VBA: (Jan 6, 2023) Master the extent and scope of your VBA variables for code that's efficient, effective, and easy to maintain.

Choosing the Proper Lifetime of Variables in VBA: (Jan 9, 2023) Some values should be calculated every time you need them. Others should be stored for performance reasons. But how do you decide which way to go?

Block-Level Scope in VBA...Does Not Exist: (Jan 11, 2023) VB.NET and VBA may look the same, but there are some important differences. This is a little-known feature of VB.NET that I really wish was available in VBA.

Idempotence vs. Determinism: (Feb 2, 2023) Idempotent functions can safely be run multiple times. Deterministic functions always return the same output given the same inputs. Let's explore further.

Enums in VBA: A Great 10-Minute Introductory Video: (Feb 3, 2023) Excel MVP Paul Kelly packs a bunch of great information (including a well-hidden feature) into this ten-minute video introducing Enums in VBA.

VBA to T-SQL via TDD

["VBA to T-SQL via TDD" tag page]: Show all articles with the tag "VBA to T-SQL via TDD" (including those where "VBA to T-SQL via TDD" is a secondary tag).

How to Convert a VBA Function to a SQL Server Scalar Function: (Sep 3, 2021) MS Access Developers Can Remove All the Risk From This Complex Process With These 3 Words

VBA to T-SQL via TDD: Step 1: (Sep 6, 2021) Step 1. Identify or create test data in Microsoft Access

VBA to T-SQL via TDD: Step 2: (Sep 8, 2021) Step 2. Build a "test table population query" in Microsoft Access

VBA to T-SQL via TDD: Step 3: (Sep 9, 2021) Step 3. Create a temporary test table in SQL Server

VBA to T-SQL via TDD: Step 4: (Sep 10, 2021) Step 4. Use the results of your Access query to populate the test table

VBA to T-SQL via TDD: Step 5: (Sep 11, 2021) Step 5. Create a dummy scalar function in SQL Server

VBA to T-SQL via TDD: Step 6: (Sep 13, 2021) Step 6. Build a test query in SQL Server to return failing tests

VBA to T-SQL via TDD: Step 7: (Sep 14, 2021) Step 7. Execute the test query in SQL Server to verify it fails

VBA to T-SQL via TDD: Step 8: (Sep 15, 2021) Step 8. Alter the scalar function to address failures

VBA to T-SQL via TDD: Step 9: (Sep 16, 2021) Step 9. Execute the test query in SQL Server

VBA to T-SQL via TDD: Step 10: (Sep 17, 2021) Step 10. Repeat steps 8 & 9 until all tests pass

Version Control

["Version Control" tag page]: Show all articles with the tag "Version Control" (including those where "Version Control" is a secondary tag).

High Wire Walking With No Net: (Sep 4, 2020) In those early days, our method of "source control" was making regular copies of the front-end database and appending a date to the filename. This was....less than ideal. The problem is best illustrated with a quick story.

An Homage to Mercurial: (Sep 7, 2020) I believe without a doubt--even knowing what I know now--that I made the right decision at the time. If I could go back to 2009 and do it over again, I would still go with Mercurial. If I were starting from scratch in 2020...that's a different story.

No Longer Set: (Sep 8, 2020) Using version control is the most impactful change you can make to improve the quality of your Microsoft Access applications. Here is a quick list of just some of the benefits you gain using version control.

The Starting Point: (Sep 9, 2020) Before we can use a DVCS with our Access application, we need to convert the binary Access file into a series of text files. The best place to start (and where my journey began) is with this StackOverflow answer.

No Longer Set: (Sep 10, 2020) How do we save database properties to text? By iterating through the database's .Properties collection, of course. Here is some sample code...

Tables to Text: Do it for the DVCS!: (Sep 13, 2020) Anything that can lead to a bug in your software belongs in version control. That includes local tables with design-time data.

Referencing references: (Sep 14, 2020) While we can use the VBA user interface to display the references, we can't rely on that approach if we want to automate exporting our Access binary file to text files. Luckily, there is a solution.

Tracking Table Structure Changes: (Sep 15, 2020) Another potential source of bugs is changes to the structures of our tables. This includes both local tables and linked tables that reside in our back-end.

Exporting Queries for Version Control: (Sep 16, 2020) SaveAsText will export queries to text files, but calling those files "human-readable" is a stretch.

Putting It All Together: (Sep 17, 2020) I expanded on the original decompose.vbs script. The code below is the culmination of more than 50 individual changes and tweaks over 10+ years.

Access Version Control: My Philosophy: (Sep 18, 2020) These rules are intended as a guiding philosophy. If I'm getting closer to meeting this vision, I know I'm moving in the right direction.

Scraps of Wood and Code: (Oct 13, 2020) Resisting the packrat mentality.

Migrating Mercurial: (Nov 25, 2020) I had to update the settings file for 120 Mercurial repositories. I saved hours of tedium using a regex in the "Find in Files" feature of Notepad++.

Tracking Schema Changes: (Jan 28, 2021) If it can cause a bug in your software, you should be tracking it in version control. Database schema changes absolutely fall into that category.

Peace of Mind from Version Control: (Mar 9, 2021) "Do you want to save your changes?" No, not if I just added temporary debugging code. But, Yes, if I also added production code. What to do?

It's All About the Diff: (Mar 17, 2021) How can you figure out what you changed on a form when you can't remember changing anything on that form? Version control, of course.

Reverting Unwanted Changes: (Mar 18, 2021) Using Version Control in Access is like having a time machine that makes it easy to undo design mistakes. Here's a quick overview of the process.

A Quick, Free Way to Try Version Control with Microsoft Access: (Jul 9, 2021) Curious about getting started with version control in Microsoft Access, but don't want to commit a lot of time or money? This could be just the solution for you.

Learn to Love Text-Based Version Control with "Highlights for Children": (Jul 29, 2021) Why use text-based version control for visual objects like forms and reports? I'll tell you why, but first, find all the differences between these two pictures...

Video

["Video" tag page]: Show all articles with the tag "Video" (including those where "Video" is a secondary tag).

VIDEO: Modern On Off Buttons in Access: (Jul 27, 2022) I recorded a YouTube video that demonstrates how to implement the Modern On/Off button feature that I wrote about yesterday.

Access Job Interview Questions: (Aug 26, 2022) Richard Rost--today's most prolific creator of Microsoft Access video tutorials--has put together a great baseline of questions and answers that test your Access knowledge.

Access Job Interview Questions: Follow-up Q&A: (Aug 30, 2022) Topics covered include Access security best practices, "deploying" trusted locations to users, and avoiding reserved words when naming database objects.

VIDEO: Sorting Continuous Forms: (Sep 2, 2022) A 12-minute video that shows you how to implement my NewSort and UseHand functions for sorting continuous forms in MS Access.

VIDEO: "Codifying" Long Names: (Sep 12, 2022) Former Access MVP Jack Stockton translates my SQL Server "Codify()" function to work with Microsoft Access backend databases.

VIDEO: Design Patterns with Access: (Sep 29, 2022) "I fear not the man who has practiced 10,000 kicks once, but I fear the man who has practiced one kick 10,000 times." How Bruce Lee's advice applies to MS Access.

Watches

["Watches" tag page]: Show all articles with the tag "Watches" (including those where "Watches" is a secondary tag).

Watch Expression: (Mar 6, 2021) A deeper than necessary dive into the exact expression evaluation behavior of the basic "Watch Expression" in VBA.

Break When Value Is True: (Mar 7, 2021) When debugging VBA, you can watch an expression and halt code execution as soon as it evaluates to True. Let's explore exactly how that works.

Break When Value Changes: (Mar 8, 2021) When debugging VBA, you can watch an expression and halt code execution whenever its value changes. Let's explore exactly how that works.

Week in Review

["Week in Review" tag page]: Show all articles with the tag "Week in Review" (including those where "Week in Review" is a secondary tag).

Week in Review: May 7, 2022: (May 7, 2022) Highlights include an IE integration article from Daniel Pineault, an Access tool from Crystal Long, and a PowerApps User Group video.

Week in Review: May 14, 2022: (May 14, 2022) Highlights include the Access Dataverse Connector *finally* reaching General Availability, the public release of 3 DevCon videos, and another big Access bug.

Week in Review: May 21, 2022: (May 21, 2022) Highlights include a Microsoft Access Roadmap update, sample code for trig functions, and a discussion about preserving Access tips of yore.

Week in Review: May 28, 2022: (May 28, 2022) Highlights include two new Access bugs, a modern On/Off toggle control, setting list box font colors by column, and resurrected videos from the Access forums vault.

Week in Review: June 4, 2022: (Jun 4, 2022) Highlights include major changes to the Access roadmap, Richard Rost's Beginner Access video course is now free, and research on developer interviews.

Week In Review: June 11, 2022: (Jun 11, 2022) Highlights include a better date picker control, dashboard-style gauges, and drawing shapes in Access reports.

Week in Review: June 18, 2022: (Jun 18, 2022) Highlights include building custom progress bars, creating organizational charts, and yet another Access bug [sigh].

Week in Review: June 25, 2022: (Jun 25, 2022) Highlights include an elegant solution to synchronized scrolling, a novel approach to db schema versioning, and a deep dive into recovering deleted db objects.

Week in Review: July 2, 2022: (Jul 2, 2022) Highlights include a deep dive into the Autoexec macro, compacting the current database via VBA, and a massive Access drawing reference.

Week in Review: July 9, 2022: (Jul 9, 2022) Highlights include code to activate a specific ribbon tab, a deep dive into the innards (and dangers) of multivalue fields, and--yes--more Access bugs.

Week in Review: July 16, 2022: (Jul 16, 2022) Highlights include 5 things NOT to do when writing code, embedding videos on Access forms, and--of course--more bugs. :-(

Week in Review: July 23, 2022: (Jul 23, 2022) Highlights include the latest edition of Karl Donaubauer's Access News, creating a custom splash form, and the public release of the SSMS-style "Access Studio" tool.

Week in Review: July 30, 2022: (Jul 30, 2022) Highlights include tips for designing Access apps for tablet use, sorting forms by combo box columns, and CUPID--an alternative to SOLID principles.

Week in Review: August 6, 2022: (Aug 6, 2022) Highlights include the list of Access fixes for Version 2206, a deep dive into how Access stores queries, and a rant against today's overly complicated forums.

Week in Review: August 13, 2022: (Aug 13, 2022) Highlights include Peter Cole's 32 to 64-bit conversion presentation, a deep dive into how Access stores queries, and a sad announcement from MVP Daniel Pineault.

Week in Review: August 20, 2022: (Aug 20, 2022) Highlights include Colin Riddington's Nav Pane Helper, Richard Rost's Access Developer Interview Questions, and Rick Hanson's Used Book Business Access App.

Week in Review: August 27, 2022: (Aug 27, 2022) Highlights include a dedicated web page for the Access Europe User Group, a Nav Pane Helper Add-in, and a deep dive into database theory.

Week in Review: September 3, 2022: (Sep 3, 2022) Highlights include an add-in to check Access/Windows/Office versions, a query metadata viewer, and multiple ways to change the mouse cursor in MS Access.

Week in Review: September 10, 2022: (Sep 10, 2022) Highlights include a major milestone for (and giveaway from) Richard Rost, a data classification guide, and an Access QR code generator.

Week in Review: September 17, 2022: (Sep 17, 2022) Highlights include a new YouTube channel from Daniel Pineault, modern chart reference, and form resizing and "profiles" videos.

Week in Review: September 24, 2022: (Sep 24, 2022) Highlights include bug fixes in Access v2208, Microsoft's new Office update strategy, creating ACCDB/ACCDE files using code, and a series on TempVars.

Week in Review: October 1, 2022: (Oct 1, 2022) Highlights include Pivot Tables and Pivot Charts, exporting all Access tables into Excel, and many changes to future Access User Group presentations.

Week in Review: October 8, 2022: (Oct 8, 2022) Highlights include using Base64 encoding to embed images in Thunderbird, seven(!) IslaDogs articles, and episode 4 of Karl Donaubauer's Access NewsCast.

Week in Review: October 15, 2022: (Oct 15, 2022) Highlights include changes to the Access team's development priorities, adding spell check to Access, and generating Excel charts via automation from Access.

Week in Review: October 22, 2022: (Oct 22, 2022) Highlights include a reserved word checker utility, executing PowerShell cmdlets from VBA, using Access in an Azure VM, and 5 types of control tips.

Week in Review: October 29, 2022: (Oct 29, 2022) Highlights include a data macros how-to, time zone-aware dates, automating the Access nav pane, and collapsing/expanding the ribbon.

Week in Review: November 5, 2022: (Nov 5, 2022) Highlights include a new Access MVP (congrats Juanjo Luna!), a deep dive into the FileSystemObject, and using UIAutomation to interact with the ribbon.

Week in Review: November 12, 2022: (Nov 12, 2022) Highlights include two new Access User Group recordings, a WizHook sample database and reference, and a couple of videos on macro blocking.

Week in Review: November 19, 2022: (Nov 19, 2022) Highlights include multiple ways to hide sensitive data, a CDO email tester, an improved SQL editor, and updates from the Access dev team.

Week in Review: November 26, 2022: (Nov 26, 2022) Highlights include a sneak preview of Rubberduck 3.0, multiple articles on Access keyboard shortcuts, and aligning text with monospaced fonts.

Week in Review: December 3, 2022: (Dec 3, 2022) Highlights include the WizHook TwipsFromFont function, an enhanced message box, and drawing dynamic meters on Access reports.

Week in Review: December 10, 2022: (Dec 10, 2022) Highlights include Access disappearing from the Microsoft 365 Roadmap, bug fix release 2211 details, maps, maps, and more maps.

Week in Review: December 17, 2022: (Dec 17, 2022) Highlights include Access's new code signing feature, rotating and scaling images, drawing snowflakes (festive!), and a BRAND NEW Access blog.

Week in Review: December 24, 2022: (Dec 24, 2022) Highlights include tentative dates for Access DevCon Vienna, the evils of split forms, listing complex fields, and more festive Access art from Crystal Long.

Week in Review: December 31, 2022: (Dec 31, 2022) Highlights include a deep dive into creating a customer follow-up database, automatic form resizing, and a risk-minimizing approach to app rewrites.

Week in Review: January 7, 2023: (Jan 7, 2023) Highlights include 15 tips & tricks from Karl Donaubauer, the new digital signing feature for Access databases, and how to hash a string in VBA.

Week in Review: January 14, 2023: (Jan 14, 2023) Highlights include using an ActiveX control to collect handwritten signatures, multiple options for getting special folders in VBA, and managing old data.

Weeks in Review: January 28, 2023: (Jan 28, 2023) I'm back! Highlights from the past two weeks include using web APIs in Access, Rubberduck 3.0 news, using the registry from VBA, and more on ChatGPT.

Week in Review: February 4, 2023: (Feb 4, 2023) Highlights include a tool to localize Access applications (coming soon) and a couple of good (if slightly off-topic) articles on management and pricing.

Whiteboard Sessions

["Whiteboard Sessions" tag page]: Show all articles with the tag "Whiteboard Sessions" (including those where "Whiteboard Sessions" is a secondary tag).

The Knowledge Square: (Jan 15, 2022) For knowledge workers in the 21st century, it's better to know what question to ask than it is to know the answer to the question.

Microsoft Access: A Victim of Its Own Success: (Jun 6, 2022) Looking for bold new features in Microsoft Access? Don't hold your breath.

WizHook

["WizHook" tag page]: Show all articles with the tag "WizHook" (including those where "WizHook" is a secondary tag).

Wiz(): Never Forget to Set the WizHook Magic Key: (Oct 26, 2022) This convenience function handles setting the WizHook Key property with the required magic value once per session.

WizMsg(): A Simple Way to Create a MsgBox with Bold Text: (Oct 27, 2022) Bold text in a Microsoft Access message box? It's true. And it requires no API calls, no third-party libraries, and no arcane string syntax. Check out WizMsgBox!

Sorting Arrays of Strings in Access with WizHook: (Nov 2, 2022) No need to write your own array-sorting code from scratch. Use the SortStringArray method of Access's hidden WizHook object instead!

Microsoft Access WizHook References: (Nov 7, 2022) A list of all the best resources for the hidden and undocumented Microsoft Access WizHook object.