Code completion is a feature that most modern development environments have that can predict how to complete a given token in an expression as you are typing it. The advantage of this is that it can save numerous keystrokes over time, as well as freeing you from the burden of having to remember the exact name of all the methods and classes that you use in your programming vocabulary.

Code completion, in general, must strike an interesting balance in order to be effective to you, the programmer. On one hand, code completion should strive to offer an accurate and generally complete set of suggestions. While on the other hand, too many suggestions may lead to cognitive overload, which can have an adverse effect on your ability to program. The code completion engine in VA Assist Pro attempts to achieve this balance by performing real-time code analysis in order to assemble a smaller set of more relevant suggestions. The code completion offered in VA Assist Pro is a customizable experience that can be tailored to better fit your programming style.

Code completion is available in four basic contexts. These contexts are Smalltalk browsers, inspectors, workspaces and debuggers. Code completion provides unique capabilities for each context.

Configuration options for code completion are stored in the ENVY manager repository by user. This means that each user will have access to their unique set of configurations from any Smalltalk client connected to an ENVY manager instance.

Code completion configuration options can be accessed by (Options | Code Assist | Configure...) in any browser menu and selecting "Code Completion" from the Feature combo box in the Configuration UI. Because there are so many available options that allow you to customize your experience using Code Completion, a Filter combo box has been provided that shows the various options in logical categories. A complete description of each configuration option will be provided below.

The configuration UI allows you to restore the default settings for the configuration items that are in view. This gives you the ability to restore just the settings in a particular category, without affecting the settings in other categories. If you would like to restore all settings, select the "All" category in the filter combo box and press the "Restore All Defaults" button on the bottom-left of the configuration UI.

The configuration UI also gives you access to a summary of the current key bindings that can be used for various code completion actions. To see a description of these, press the "Key Bindings" button located on the bottom-right of the configuration UI.

The options in this category provide ways to tweak the Code Completion experience in a course-grained fashion, and serve as a good starting point to customizing your experience. Many of these options are supported, in various flavors, by other popular development environments that offer code completion.

The options in this category provide finer-grained tweaks that you may, or may not, be interested in. These options provide some additional ways to customize the code completion experience.

The options in this category provide settings to customize the look and feel of code completion. With these settings, you can create a customized theme for the completion popup, as well as take advantage of match highlighting.

Assuming you use code completion, you are going to be seeing the completion popup a lot! This is especially true if you have "Auto Completion Popup Enabled". Therefore, you should have some ability to control how the popup looks...and we provide that capability with an extensive set of theming options.

Being able to control the visual appearance of the completion popup can have a lot of appeal. However, we felt it was also important to find ways to use visual appearance to help increase the usability of code completion. With this in mind, code completion offers a "Match Highlighting" engine that provides visual cues for matched and unmatched regions of a candidate completion suggestion in the popup. These visual cues allow you to quickly see why completions are in the popup, what the next character to press should be and what remaining portion of a given completion in the popup has yet to be matched.
Note: Match Highlighting functionality is only available when using enhanced list widgets with the extended list widget style, which is one of the settings provided. However, some of the basic theme settings will still be available even when you're not using enhanced list widgets.

With the exception of fonts, look and feel configuration options are designed to be shared across all VAST Platform supported operating systems. Fonts require some special handling because font availability is not just operating system dependent, it can also be machine dependent. Typically, you will see more font variation between the windows and *nix systems, instead of within a given family of systems. Because of this, font configurations are stored by operating system type. While this scheme doesn't solve the issue completely, it does capture the majority of cases where, for example, you need to specify one type of font for a Linux client and another type of font for a Windows client. Even though the font setting is stored by operating system type, there are certainly situations where a specified font may not be available. For example, if you specify your font setting for code assist in a Windows 7 client, with a font only available in Windows 7, and then open a Windows XP client connected to the same ENVY manager (and as the same ENVY user), upon opening the Look And Feel configuration options for Code Completion in Windows XP you will see that it falls back to using the 'Default' font for that particular font setting. Additionally, you will see that 'Default' is drawn in red, so you will be aware that it was unable to locate the specified font. At this point, you may just go with the default, or you may wish to change the font to one that is available on Windows XP and Windows 7.

The pictures below show some examples of different combinations of theme and match highlight settings. Some of these would probably be ridiculous choices in practice, but it demonstrates some of the visual elements you will have control over:

All the settings related to look and feel are described in detail below:

In VA Assist Pro, code completion provides you with a set of "suggestions" for completing the word that you're typing. These completion suggestions come in various flavors to help you complete the different constructs available in the Smalltalk language. Code completion in VA Assist Pro is context sensitive, and can use the information from the current context to provide you with relevant suggestions. For example, if you are typing a method selector and activate code completion, it knows to only provide you with selectors that successfully complete what you're typing, and not classes and variables that happen to match your partial selector. Code completion provides suggestions to you with icons to help you quickly identify what to look for. The following is the list of constructs that can be completed, along with examples of their associated icons. In many cases, the code completion engine is able to identify the type of the object being suggested dynamically (i.e. Number, String...), and will use the icon associated with that type.

Most suggestion types are self-explanatory for a Smalltalk programmer, however there are a few suggestion types that are worth describing in more detail.

Symbol Suggestions: VAST's code completion has support for completing symbol literals. Suggestions for symbol literals are created from the Smalltalk symbol table, which is often very large. While code completion is more than happy to show you all symbols available in the system, you should understand that this is a pretty expensive operation and will take some time (which implies a second or so, instead of 100 milliseconds). You can see all symbols in the system by typing '#' and requesting code completion. You will notice that a filter notice will popup. At this point all the symbol suggestions have been prepared, they just have not been rendered in the popup yet. You may either accept the filter notice to show them in the completion popup, or you can just continue to type and it will filter on the prepared items and show the filtered suggestions in the completion popup.

Character Literal Suggestions: One of the goals of code completion is to show useful information in the completion popup at all points. While you certainly don't need assistance in typing a single character, it may be useful for you to see a set of suggestions that describes the ASCII table. This can be achieved by typing '$' followed by a request for code completion. What you will be looking at is the non-extended ASCII table, in suggestion form, and you will be able to search by name or ASCII value. This is also helpful for completing some of the non-printable characters, which are usually referenced by pool variables. Code completion is aware of what pool variables are visible in your current context and will provide a full scoped reference to a character pool variable if necessary. The following shows an example of what character literal suggestions look like.

Method Suggestions: Code completion has a unique ability to display suggestions for all possible receivers of a method. Visual cues are provided in the completion popup that allow you to tell which receiver a completion suggestion refers to. Once a method suggestion is accepted, code completion will not only apply the completion to the editor, but also auto-insert parentheses where needed. Code completion is able to do this because the selection you make tells it what the intended precedence level is, and therefore where parentheses need to be inserted so the completion will refer to the intended receiver. The following picture below shows an example of the completion popup containing method suggestions for all three precedence levels to complete the partial 'aft'. The first suggestion is a camel-case match that refers to the variable receiver 'max'. The second suggestion is a camel-case match that refers to the binary expression receiver 'min < max'. We know this because there is one yellow left arrow icon to indicate that this completion is for the receiver one level out. Finally, we have two prefix-matched suggestions that refer to the receiver 'OrderedCollection new'. Notice that there are two yellow left arrows for these suggestions, which specifies that it is intended for the receiver two levels out.

Text Manipulation Suggestions: Some other VA Assist Pro features, such as refactoring, hook into code completion which can make it easier to initiate the refactoring. Some examples of this are generating accessors and declaring an undefined temporary. These are discussed in more detail in the Refactoring section below.

Code Completion has powerful matching algorithms that allow you to narrow down the completion list to just the completions you are interested in. This section will walk through the matching algorithms that are available in VAST and describe how they work so you can search most effectively.

When completion matching is talked about, what is implied is that the user has typed a small part of a larger name that the user would like assistance completing. The part that the user has typed in will be referred to as the 'partial string'. Code completion will attempt to match the partial string against longer names that might be suitable candidates for completion. These longer names will be referred to as 'candidate completions' and these are the items that the user sees in the completion popup.

A key point to understand is that the partial string represents a pattern, and it is up to the matching algorithms to understand how to interpret that pattern. Most developers who have used code completion with other development environments are pretty comfortable with the fact that the partial string typically represents the prefix of the intended completion. So for example, if a developer wanted to complete the name 'OrderedCollection', they may type 'Ord' and request code completion with the expectation that 'OrderedCollection' will be an available candidate completion (and therefore will be an item in the completion popup). While this remains true, we will also see that VAST has matching algorithms that interpret the partial string as a pattern that describes more than just the prefix of an intended completion. This leads to more powerful searching capabilities, but these matching algorithms have their own rules which you must learn in order to use them most effectively.

Prefix Matching: Prefix matching implies that the partial string represents the prefix of an intended completion. Therefore, the candidate completions that are successfully matched using this method will have the partial string as their prefix.

In VAST Platform, you have the option of specifying that prefix matching is case-sensitive or case-insensitive. While case-insensitive means you don't have to press the <Shift> key to match uppercase characters, the trade-off is that you will most likely see more candidate completions in the popup since there may be both uppercase and lowercase matches.

CamelCase Matching: VAST Platform supports a powerful multi-mode algorithm that interprets the partial string as a pattern which can be used to match names that conform to the rules of camel case. The camel case rule set is only loosely-defined, but fairly easy to understand with some examples which will be provided. The algorithm has a few modes which can be decided by you. See the 'CamelCase Match Policy' configuration section for more information.

CamelCasing is a way to represent multiple words or phrases as a single word. This is done by removing the spaces between the discrete words, which joins them together, and then taking the first letter from each word and making it an uppercase. This last step is so you can visually tell the separation between the words since spaces are no longer present. This is far easier to describe with some simple examples, and if you program in Smalltalk, you are probably very comfortable with this concept already. Consider the Smalltalk class name 'OrderedCollection'. In this example, the adjective 'Ordered' has been joined with the noun 'Collection'. Notice that the 'C' in 'Collection' is uppercase. This uppercase character is often referred to as a 'Camel hump' in a CamelCase name. These 'Camel humps' are used as part of the partial string to specify to the algorithm that if a prefix match fails at a certain character, then jump to the next 'Camel hump' and try to continue from there. Lets look at some examples. On the left will be the pattern, or the partial string that the user has typed into the text editor. On the right will be one potential candidate string that could match the pattern:

As you can see, the partial strings are much smaller, but also convey a lot more information than just simple prefix matching. VAST Plaform takes it even one step further. Notice in the above examples that the user must type an uppercase character in the pattern to represent the 'Camel hump' of a CamelCase name. This means pressing the <Shift> key a lot in short succession. VAST Plaform will happily use this rule set, but the user may also adjust the CamelCase matching policy to 'Lenient' and let Code Completion figure out where the 'Camel humps' are supposed to be. By doing so, the above example could be modified as follows:

The CamelCase matching algorithm also provides a unique way to search Smalltalk keyword selectors. Typing the ':' is completely optional, and multi-keyword selectors can be searched using CamelCase. The following are some examples shown using the Lenient variant of the algorithm: