Review of Mastering VBA

A lot of people have asked about the next book to read after reading VBA for Dummies. Yes, the current 5th edition of VBA for Dummies still works fine as a starting point, even with issues such as dealing with the Ribbon to consider. In fact, you can find some great updates to VBA for Dummies on my blog. However, the fact of the matter is that readers have been asking for more, which is where Mastering VBA by Richard Mansfield comes into play. This is the next book you should get if you want to move on from what VBA for Dummies shows you to writing applications with greater functionality. For example, a lot of you have requested more information about creating forms and Chapters 13 through 15 will help you in this regard. Richard has done an outstanding job of moving you to the next step of creating the complex forms required for robust applications.

Another common request that Mastering VBA addresses is the need for security. While VBA for Dummies helps you understand the need for basic security, Mastering VBA takes the process several steps further and could help prevent breaches given the modern computing environment (one that didn’t exist when I wrote VBA for Dummies). Chapter 18 begins the process by emphasizing the need to build well-behaved code. After all, if your code doesn’t behave, there isn’t any set of security measures that will protect it from harm. Chapter 19 goes on to help you understand the essentials of good security, especially with all the modern threats that cause problems for developers today.

At 924 pages (versus 412 for VBA for Dummies), Richard is also able cover some topics in detail that would have been nice to have in my own book. Readers have complained about having to go online to view object model details for the various Office applications in my book. Mastering VBA provides coverage of the object model as part of the book so you can work through it without having to go anywhere else. It’s a convenience issue—readers really shouldn’t have to look for essentials like the object model online, but every author has to face space limitations when putting a book together. The object model material is spread out across the book, but there really isn’t any way to organize it so that it all appears together. This is one time when you’ll need to actually use the table of contents and index to find the material you need.

As with all the books in the Mastering series, this one has questions at the end of each chapter. These questions are designed to help you master the skills learned in the chapter. You find the answers for each of the questions in the back of the book. This makes Mastering VBA an excellent option for the classroom. More importantly, it gives you another way to learn the material in the book. The longer I write books, the more I come to realize that one or two methods of learning simply won’t do the job. This book usually provides three or four ways to learn each task, which means that you have a higher probability of actually mastering the material (as defined by the title).

For all of you who have been asking for the next book after VBA for Dummies, Mastering VBA is the one that gets my recommendation. Until I actually have time to write a book that specifically addresses the concerns in the reader e-mails I’ve received, this book is your best option. No, it doesn’t address every e-mail request that I’ve received, especially with regard to form creation, but it does answer a considerable number of them. Of course, I’ll look forward to your continued interest in my book and I hope you keep those e-mails coming my way!

 

VBA Examples Online

When I originally wrote VBA for Dummies, I included a number of links to third party resources. Of course, a few of those links are no longer active. I was really happy to hear from JoJo Zawawi the other day about the link to his excellent VBA examples. The link found in my book, http://www.jojo-zawawi.com/code-samples-pages/code-samples.htm, is no longer active. You need to use http://www.thezcorp.com/VBACodeSamples.aspx instead.

If you ever find a broken link in one of my books, please be sure to let me know about it. I’ll be more than happy to provide an updated link here so everyone can continue to use the resource. Please contact me about your link concerns at John@JohnMuellerBooks.com.

 

Examining the Calculator in Windows 7 (Part 2)

A while back, over two years ago in fact, I uploaded a post entitled, “Examining the Calculator in Windows 7.” Since that time, a number of people have asked about the other features that the new calculator includes. Yes, there are these rather significant problems that Microsoft has introduced, but there are some good things about the new calculator as well.

The good thing appears on the View menu. When you click this menu, you see options at the bottom of the list that provide access to the special features as shown here.

The View menu includes options for unit conversion, date conversion, and worksheets.
The Windows 7 Calculator View Menu

The Unit Conversion and Date Conversion options are the most useful. However, the worksheets can prove helpful when you need them. Of the new features, I personally use Unit Conversion the most and many people likely will. After all, it’s not often you need to figure out a new mortgage, vehicle lease amount, or the fuel economy of your vehicle (and if you do such work for a living, you’ll have something better than the Windows Calculator to use). To see what this option provides, click Unit Conversion. You see a new interface like the one shown here:

The Unit Conversion display makes it possible to convert from one unit of measure to another.
Calculator Unit Conversion Display

You start using this feature by selecting the type of unit you want to convert. As you can see from this list, the kinds of conversions you can perform are extensive:

Select a conversion type to determine what options are offered in the From and To fields.
The Calculator Supports a Healthy List of Conversion Types

The option you select determines the content of the From and To fields. For example, if you want to convert from kilometers to miles, you select the Length option. After you select the type of unit, type a value in the From field and select the From field unit of measure. Select the To field unit of measure last. Here is what happens when you convert 15 kilometers to miles:

The output shows that converting 15 kilometers to miles equals 9.32056788356001 miles.
Converting Kilometers to Miles

I’ve found use for most of the entries in the types list at one time or another. Every one of them works quite well and you’ll be happy they’re available when you need them. The Data Calculation option can be similarly useful if you work with dates relatively often, as I do. However, I can’t see many people needing to figure out the number of days between two dates on a regular basic. Even so, this feature is probably used more often than any of the worksheets.

The ability to perform conversions of various kinds and to access the worksheets that Windows 7 Calculator provides isn’t enough to change my opinion. The implementation of the Calculator is extremely flawed and I stick by my review in the first posting. However, you do have the right to know there are some positives, which is the point of this post. Let me know your thoughts about Calculator now that you have a better view of it at John@JohnMuellerBooks.com.

 

VBA Book Needs and Wants

A lot of people still buy VBA for Dummies even though this book has gotten a little long in the tooth. The reason is simple, the book still works fine because Microsoft has put little effort into making VBA a better language. Even though the idea was that people would move to Visual Studio to create Microsoft Office add-ons, the fact is that most of the people using VBA have no desire whatsoever to make the move. In addition, there is a huge base of VBA resources available and no business in its right mind would ever stop using them as long as they get the job done. So, the fact of the matter is that VBA for Dummies will continue to be a great book for your shelf.

However, I also realize the book has shortcomings. It goes too far in some directions and not nearly far enough in others. The blog posts for this book point out a number of these flaws and provide fixes for them. In addition, people have been asking for a “next book” for quite some time now. With this in mind, I’m currently working on ideas for that next book, the one that you want to put right beside VBA for Dummies on your shelf to get a fuller picture of what VBA can do for you and to act as a resource when you need it.

So far I have collected well over 1,200 reader e-mails for this book. Certainly, I have enough ideas to start another book. However, I do want to hear from you. What sorts of things do you consider essential for that next book? Some readers have suggested that I open my book up to products other than Microsoft Office. There are a number of them out there that do use VBA (or something close enough that knowing VBA helps quite a lot). Other readers have requested better information about forms and still others want to see a full-fledged application of some sort. Many of the e-mails I receive talk about interoperability between Office products. In short, there are a lot of potential areas that you could tell me you need, but perhaps you have some unique need that I should consider.

VBA for Dummies is a great book that continues to sell well and I want to support your coding efforts in every way that I can. What I need are ideas that would generally appeal to everyone. Don’t send me a request to provide what amounts to free consulting for your specific application. A request to provide better support for forms that help format content is a valid request; a request to demonstrate access connection techniques for your company’s local intranet won’t work at all. Contact me with your ideas for that next book at John@JohnMuellerBooks.com.

As always, thank you for the incredible level of support you have provided me over the years. I continue to be amazed at some of the e-mails I receive. These ideas would be just another example of your desire to have high quality technical books on your shelves.

 

VBA’s Long Lasting Viability

Microsoft has taken great pains over the years to try to kill VBA off. I’ve discussed some of the issues surrounding this effort in two previous posts: VBA and Office 2013 and VBA and Office 2013 (Part 2). Because of these efforts, a number of people have written to ask me about VBA and my book about it. The fact of the matter is that most of the examples in VBA for Dummies continue to work fine and VBA remains a viable development platform for applications. Microsoft’s efforts to move VBA developers to Visual Studio Tools for Office (VSTO) haven’t been as successful as Microsoft would like—mostly because most VBA developers have other careers and don’t want to learn how to use VSTO.

I do continue to provide updates for my book in the VBA for Dummies category of this blog. The latest such post discusses trigonometric calculations in VBA. As you find book issues, I’ll continue to address them in this blog. In addition, as time permits, I’ll discuss VBA issues in general and provide additional examples that relate to the content in my book. All I really need is your input at John@JohnMuellerBooks.com to know what sorts of content you’d like to see. Your e-mails help me decide which issues are most important to you, so please do write when you see a particular need.

Of course, the biggest question about VBA is the one I haven’t answered yet. Some people have wondered whether VBA is still a viable language for new development. The fact that even Microsoft has provided updated macros for VBA should tell you something. If there were no interest in new development, you can be sure that Microsoft wouldn’t waste time in posting macros for Office 2013. In fact, a Google search shows 122,000 hits for sites that have updated their VBA information in the last year. That’s a lot of interest in a language that Microsoft has tried so hard to kill off.

I still see VBA as the language to use when you have any sort of Office automation need—VSTO is a better choice when you actually want to extend Office functionality or define new behaviors (work that full-fledged developers normally perform). It’s incredibly easy to use and most people can learn to use the basic features quite quickly. In fact, because it’s interpreted, VBA makes a great way for people to start learning basic programming principles.

The only caveat for today is to ensure that your code doesn’t have any compatibility issues, especially if you plan to use your VBA macros with Office 365. There is a lot of old code out there that might not work with newer versions of Office. With this in mind, Microsoft has created the Office Code Compatibility Inspector (OCCI). Make sure you download as use this tool to check your code.

 

Using the Trigonometric Functions in VBA

It’s gratifying to know that people are still buying and using VBA for Dummies to perform useful work. I still get a fair number of reader queries about the book and I’ve tried to provide updates to keep the book useful as part of my blog. So, I was appalled recently to find that there is an error in one of the examples. The error appears in both the 4th edition of the book (on page 83) and in the 5th edition book (on page 99). It affects the use of trigonometric functions to perform various kinds of calculations involving angles.

Most of us are used to thinking about angles in degrees. However, most mathematicians use radians, not degrees, when working with angular measurements. The main reason for using radians is that degrees measure direction, rather than the angular part of a circle (there is actually some discussion about this whole issue and it’s off topic, so I’ll leave any thoughts on the matter to you). If you’re really interested in the detailed math, check out the articles Why Use Radians instead of Degrees? and Radians and Degrees. The bottom line is that Microsoft uses radians, not degrees, when providing trigonometric functions to make them mathematically correct, but completely confusing to the rest of us.

The example uses a measurement of 45 degrees as input to the trigonometric functions: Atn(), Sin(), Cos(), and Tan(). However, to make the input work correctly with the functions, you must first convert the degrees to radians. The corrected example looks like this:

Public Sub ScientificCalcs()
    ' Define an input value
    Dim MyInt As Integer
    MyInt = 45
     
    ' Convert input to radians.
    Dim Converted As Double
    Converted = WorksheetFunction.Radians(MyInt)
     
    ' Create an output string.
    Dim Output As String
     
    ' Display the trigonometric values for a 45 degree
    ' angle.
    MsgBox "The original angle is: " + CStr(MyInt) + _
           vbCrLf + "The value in radians is: " + CStr(Converted) + _
           vbCrLf + "Arctangent is: " + CStr(Atn(Converted)) + _
           vbCrLf + "Cosine is: " + CStr(Cos(Converted)) + _
           vbCrLf + "Sine is: " + CStr(Sin(Converted)) + _
           vbCrLf + "Tangent is: " + CStr(Tan(Converted)), _
           vbOKOnly, _
           "Trigonometric Values"
            
    ' Change the sign of the number using Sgn and Int.
    ' Add the value to Output each time.
    Output = "The sign of 0 is: " + CStr(Sgn(0))
    MyInt = -45
    Output = Output + vbCrLf + _
             "The sign of " + CStr(MyInt) + " is: " + _
             CStr(Sgn(MyInt))
    MyInt = Abs(MyInt)
    Output = Output + vbCrLf + _
             "The sign of " + CStr(MyInt) + " is: " + _
             CStr(Sgn(MyInt))
    MsgBox Output, vbOKOnly, "Using Sgn and Abs"
End Sub

Actually, the updated example also demonstrates the use of the WorksheetFunction object, which is something that isn’t covered well in the book now. Notice how the code converts the number of degrees into radians using the WorksheetFunction.Radians() function. The WorksheetFunction object provides access to a host of useful functions and you really need to check it out if you work with Excel on a regular basis. The new version of this example outputs the correct values for sine, cosine, tangent, and arctangent as shown here.

ScientificExample

Please let me know if you have any questions about this updated example. Let me know about any other concerns you have about this book at John@JohnMuellerBooks.com.

 

VBA and Office 2013 (Part 2)

I had posted some comments about using VBA with Office 2013 in my VBA and Office 2013 post. This post was based on the preview and not on the released product. Even so, most of the comments in that post still hold true. If you’re working with the desktop version of the product, you’ll find that most of the examples in VBA for Dummies will still work fine. However, the book is getting long in the tooth and the last version of Office that worked absolutely perfectly with the book was Office 2003. Since that release, Microsoft has made it progressively harder to use VBA as a viable development solution for the power user, hobbyist, and even the less skilled developer.

There are some new issues for Office 2013 that you need to know about. Most notably, it appears that some people can’t even access the Templates folder any longer without resorting to a kludge. By default, Office 2013 displays the Office.com templates and hides your personal templates, which should be a real productivity killer for the enterprise environment where custom templates reign. Yes, there is a fix for the problem (just click the links I’ve provided), but the issue is that you have to apply the fix to individual systems.

The fact of the matter is that Microsoft is making it abundantly clear that it would prefer that you not write applications for Office unless you’re willing to use Apps for Office. However, the process for creating an application in this manner is hardly as straightforward or as easy as using VBA. As far as I know, the template issue only affects one of the examples in Chapter 11. Please let me know if other chapters are affected by this issue (or any other Office 2013 issue for that matter). You can use the example in Chapter 11 after you apply the fix that is provided by Microsoft or third parties for regaining access to your personal templates.

Microsoft is also making a strong push for Office 365. This online version of Office can’t use VBA in any form. Even if you have your own templates and have carefully crafted VBA macros that would run with the desktop version of the product, you’re out of luck when it comes to Office 365. If you have this version of Office, you simply can’t use my book—attempting to do so is a waste of time.

You can continue to get full support for VBA for Dummies with desktop versions of Office, but may have to resort to some special changes as Microsoft makes Office less amenable to use with VBA. Please make sure you read the VBA for Dummies posts on my blog for updates and help with both Office 2007 and Office 2010 before contacting me.

Anyone who is attempting to write VBA macros for Office 2013 is in for a rough time and I’m sorry to see an era of personal productivity through VBA enhancement passing. If you own Office 2013 and contact me regarding VBA for Dummies, I’ll provide the best help that I can to you, but this support will be necessarily limited. Thank you for your continued support of my books. Perhaps I’ll eventually write an Apps for Office book to supplant VBA for Dummies. Please contact me with any concerns you have at John@JohnMuellerBooks.com.

 

Displaying a Telephone Number in VBA

A number of readers of VBA for Dummies have now asked me how to insert a telephone number into documents using a macro. It turns out that this is a common topic online. Microsoft should have added this feature some time ago, but apparently hasn’t (and probably won’t at this point). Most of the solutions I’ve seen are complex when this really isn’t a complex task. This post discusses three techniques:

 

  • Insertion as text
  • Insertion in a field
  • Insertion in a control on the document.


Insertion as Text

The first approach is to insert the telephone number as text. You obtain unformatted input from some source, use the Format() function to format it, and then insert it at the current cursor location.

The first thing you need to do is gain access to the developer tools if you’re using Office 2010. The VBA in Office 2010 post tells you how to perform this task. Create a new module for your document or template using the instructions I’ve provided in the Adding a Module section in Chapter 3 of VBA for Dummies. At this point, you can create a new macro for inserting the telephone number. Here’s some simple code you can try.

Sub InsertTelephoneNumber1()
    ' Obtain the telephone number.
    Value = InputBox("Type the telephone number", "Telephone Number")
     
    ' Insert the telephone number directly.
    Selection.InsertAfter Format(Value, "(###) ###-####")
End Sub

The InputBox() call simply provides the means for obtaining a telephone number. You can use any source desired. The Selection.InsertAfter call inserts any text you provide after the current cursor location. The Format() function takes the input you received as the first argument (Value) and formats it using the picture you provide. You can find information about the Format function on MSDN at http://msdn.microsoft.com/library/office/gg251755.aspx.

Insertion as Field

The second approach is working with a field. It’s a little harder to create a field that contains a telephone number, but only slightly. Formula field codes are somewhat misunderstood and this particular example uses a trick that I haven’t seen others use online for some odd reason. This is one time when using the Macro Recorder will save you time. I discuss using the Macro Recorder in the Using the Macro Recorder section in Chapter 3 of VBA for Dummies. I used these steps in Office 2010 to create the example that follows later.

 

  1. Start the Macro Recorder. Call your macro InsertTelephoneNumber2 or anything else appropriate and add a comment.
  2. Choose Insert | Quick Parts | Field. You see the Field dialog box shown here.
    Telephone01
  3. Select the = (Formula) option in the Field Names list and then click Formula. You see the Formula dialog box shown here.
    Telephone02
  4. Type any ten digit number in the Formula field as shown.
  5. Type (###) ###’-‘#### in the Number Format field as shown. Notice especially the use the single quotes (‘) around the dash. This addition is where most people make their mistake in working with these formula fields. Any text you surround with a single quote like this is treated as text. Otherwise, the dash will simply disappear.
  6. Click OK. Word will add the field to the display. Notice that the field is formatted precisely as you’d expect, including the dash.
  7. Stop the Macro Recorder. Word will create the macro for you.


At this point, you have a macro that will insert a field containing a specific telephone number. To make the field more generic, you’ll need to modify the code to accept input. Here’s a simple version that you can try.

Sub InsertTelephoneNumber2()
    ' Obtain the telephone number.
    Value = InputBox("Type the telephone number", "Telephone Number")
     
    ' Use a field to display the telephone number.
    Selection.InsertFormula Formula:="=" + Value, NumberFormat:= _
        "(###) ###'-'####"
End Sub

Again, the code obtains a telephone number using an InputBox. You can use any source desired. It then calls Selection.InsertFormula with the content you want to use as the first argument and the format for that content as the second argument. Notice that that call relies on named arguments to avoid any potential problems. In addition, notice that the equals sign (=) is in double quotes (“), but that Value is outside of those double quotes because you want the value it contains, and not the word “Value” as input to InsertFormula.

Insertion as Control

The third technique is to create a control, allow the user to input the data, and then reformat the text in the control. Controls are different because they require a little better understanding of how Word works. When you have a control, it generates events. The event handler listens for those events and then does something about them. Think about a house fire. There is a fire in your home. So, you go out to the woods and yell, “There is a fire in my home!” Nothing happens. That’s because there is no handler in the woods for the event of a fire in your home. When you call 911, the 911 operator, the event handler, listens to you yell, “There is a fire in my home!” Now something happens. The 911 operator calls the fire trucks and sends them to your house to put out the fire.

It’s time to see how all of this works in the real world. I’m assuming that you’re using Word 2010 and that you have saved your document in .DOCM (document with macros) format. The following steps get you started.

 

  1. Choose Developer | Plain Text Content Control. You see a new Plain Text Content Control added to your document.
  2. Choose Developer | Properties. You see the Content Control Properties dialog box shown here.
    Telephone03
  3. Type Telephone Number in the Title field and TN in the Tag field. Click OK. Word changes the properties of the Plain Text Content Control.
  4. Choose Developer | Visual Basic. You see the Visual Basic editor open.
  5. Right click the Project (<Document Name>)\Microsoft Word Objects\ThisDocument object in the Project Explorer window and choose View Code from the context menu. You see a module window open. (If you don’t see the Project Explorer window, choose View | Project Explorer to display it.)
  6. Select Document from the Object drop down list box in the module window (the one on the left). Word may automatically create an event handler for the New event. Remove this code because you don’t need it.
  7. Select ContentControlOnExit from the Procedure drop down list box in the module window (the one on the right). Word automatically creates the Document_ContentControlOnExit() event handler for you.


Now that you have an event handler, you have to tell it to do something. Just as the 911 operator needs to know what to do, so does Word. Here is an example of the code you could use to automatically format user input as a telephone number.

Private Sub Document_ContentControlOnExit( _
    ByVal ContentControl As ContentControl, _
    Cancel As Boolean)
 
    ' Verify the control's name.
    If ContentControl.Tag = "TN" Then
     
        ' Format the data in the control.
        ContentControl.Range.Text = _
        Format(ContentControl.Range.Text, "(###) ###-####")
    End If
End Sub

The Document_ContentControlOnExit() event handler receives two variables when Word calls it. The first contains all the information you need about the control that generated the event. The second lets you cancel the action when you detect a problem.

You only want to change controls that have a Tag value of TN. So, the first task is to detect controls of this type. The code then uses the ContentControl.Range.Text property to change the control’s text using the Format() function.

Bottom Line

These are three simple methods for adding a formatted telephone number to a Word document. However, you can extend these methods to format any sort of content. Just remember some of the rules you’ve learned here about working with formatted fields and then spend a little time with the Microsoft documentation to learn what else you can do. Please let me know if you have any questions about these techniques at John@JohnMuellerBooks.com.

 

VB2TheMax No More

A reader sent me an email this morning about an unfortunate change to one of the links in VBA for Dummies—one that I’m sure many readers will find offensive. It seems that someone has taken over the VB2TheMax site listed in the “Locating Just the Right Code” section in Chapter 17 of the 5th Edition of the book. This URL is located on page 387 of the English version of the book, but it may appear on a different page if you use a different language version of the book (or an older edition). The point is that I’m embarrassed about the change and apologize to everyone who finds the change offensive. I obviously couldn’t foresee that the site would be taken over by pornography when I originally included it in the book. Unfortunately, it appears that the site is no longer active and there isn’t any replacement for it that I can recommended. If anyone has an alternative URL, please send it to me at John@JohnMuellerBooks.com.

This brings me to a larger issue about URLs in books. They get outdated. In many cases, the URL simply fails to work because the owner takes the site down. If you ever find an outdated URL in one of my books, especially of the sort discovered by this reader, please let me know about it. I would prefer not to offend anyone and I’ll always provide updated URLs as I become aware of them.

 

VBA and Office 2013

First, the good news about Office 2013. Despite Microsoft’s best efforts to kill VBA off, it still hasn’t managed to do so. In running the various examples supplied with VBA for Dummies, I find that they all apparently run the same as they do for Office 2010. Consequently, you should still be able to follow the examples in my book without too much trouble. The Ribbon definitely will cause the same amount of trouble as it always has and you should read the posts in the VBA for Dummies category of this blog when working through the book. Remember that these assumptions are based on the current Office 2013 Customer Preview and not on a released product. I also tested the examples on Windows 7, rather than Windows 8. If anyone encounters issues working through the VBA for Dummies examples, I’d very much like to hear about them at John@JohnMuellerBooks.com.

Second, the bad news (isn’t there always some bad news). I’ve been reading about some of the experiences other people have had with Office 2013. In fact, I’ve been trying to test some of these concerns as I work with Office 2013 because I’m almost certain that some of you will write me about them. Most of the issues seem to run on the esoteric side. For example, a number of people are reporting that Office 2013 has problems with animations that are supplied as part of a VBA macro. The issue seems to be one of timing, which is probably one of the more difficult aspects of a VBA macro to troubleshoot. My advice with these sorts of issues is to focus on the macro output for right now. When the inputs and outputs work as expected, the user is generally happy. Yes, features such as animations add pizzazz, but they don’t necessarily help users perform useful work. Even so, Microsoft will probably fix a few of these issues before product release. To obtain the best help with your particular question, check out the Microsoft Office forum.

Third, the surprise news is that Microsoft is even mentioning VBA in some of the Office 2013 documentation for developers. You can find an overview of developer information at What’s new for Office 2013 developers. Many of the changes you’ll find are quite technical (such as working with the new DataModel object model). I was also quite happy to see that there is a new user interface (a task pane) for creating the XML mappings required for content controls, so you don’t have to resort to using any of those weird file manipulation methods of the past. Once Office 2013 is released, I’ll cover a few of these topics in my blog. Make sure you check out the pages for the individual applications as well:


It’ll be interesting to see how users react to the modified Office interface. My thought is that Microsoft is trying to reduce the power consumption of its applications by reducing the complexity of the user interface. However, no one at Microsoft is really saying much except that the older Aero interface looks dated and cheesy.

You’ll also want to remember that Microsoft is maintaining VBA, not really enriching it in any significant way. If Microsoft had its way, VBA would disappear with the flash of a magician’s hand. Unfortunately for Microsoft, far too many people still use VBA to create productive applications. The Visual Studio Tools for Office (VSTO) add-on has attracted a lot of attention from professional developers, but it’s far too complex for the typical office manager to use. The new focus is on something called Apps for Office. The overview for this new technology doesn’t fill me with a lot of hope that it’ll replace VBA anytime soon, but I’d love to hear your opinion about it.

For better or for worse, you’ll soon be finding yourself supporting another version of Office. In this case, you’ll likely find that VBA takes a few more hits in the compatibility zone. Microsoft is pushing hard to get developers to use anything other than VBA and developers seem equally convinced that VBA is still the right choice. I support using the right tool for the job. As long as VBA provides a simple environment for creating macros that perform useful work with a minimum of headaches, I’ll continue supporting it. In that regard, count on my continued support for VBA in Office 2013.