Every editor has a more or less good search function to search for text, numbers and characters. UltraEdit has integrated so many flexible options for this functionality that it will warrant and extensive explanation; but it is a worthwhile investment as it provides the user with extremely powerful tools for his daily usage. We would like to describe the functionality in the following text and use various practical examples to show why the search functions of UltraEdit are considered so outstanding by many users.

Quick Find

Quick Find is the function that is intended for quick lookups and can be opened using the key combination Ctrl + F. This opens a small box in the top right-hand corner, which is helpful if the user wants to search quickly without using the large/normal search function.

Figure 1: Quick Find fly-out box

It is particularly practical that UltraEdit enters the word at the position of the cursor in the search field by default.

Note: The key combination Ctrl + F can be changed in the UltraEdit settings. To do this, go to the Key mapping category in the UltraEdit settings and select Quick find in the list. The existing key combinations are displayed in the right area and a new combination can be defined directly below.

Find and Replace dialog

The actual search is handled in UltraEdit via the Find and Replace dialog, which is displayed with 4 tabs at the top: Find, Replace, Find in Files and Replace in Files.

This dialog can be launched via the menu, the ribbon icons and various key shortcuts, whereby the desired tab is preselected depending on the key combination:

The figure below shows the Find and Replace dialog in its standard display, whereby the word located at the cursor is automatically transferred to the search field:

Figure 2: Find and replace dialog

The search parameters are as extensive as the user wants them to be. In the default setting, the dialog shows basic functions. Use the gear symbol at the bottom to open the advanced search options:

Figure 3: Find and replace dialog with its advanced options

Two further keyboard shortcuts are required to navigate through the search results:

• F3 or Shift + F3: Find next result
• Ctrl + F3: Find previous result

The In section defines the used search parameters, which includes current/all open files or the selected text. In addition to the options for searching for whole words, case sensitivity, and counting the number of matches found, there are many practical power functions that I have appreciated for many years and have fortunately found again in UltraEdit. This also has to do with editing source code, for example in C++ or in Delphi as well as in other languages. 

One feature I’ve used a lot in the past is the highlighting of all matches found. When I write source code, as in the following screenshot in Object Pascal/Delphi, and enable the option Highlight all items found, all hits found are highlighted in color, which gives me a better overview of where further adjustments may be necessary:

Figure 4: Find option for highlighting all items found

I also find the option List lines containing string extremely useful, whereby a new result dialog with the string matches is displayed after the search. By double-clicking on a line, UltraEdit jumps directly to the respective line. This option is very similar to the Microsoft Word search function, for example, whose results navigation I really appreciate and I am all the more pleased that UltraEdit also makes this possible.

Regular expressions are also an important major topic in all kinds of searches. UltraEdit also supports them extensively and they will be described in more detail later in this text.

To conclude the Find function, let’s talk about the 3 button symbols above:

• Circle with clock inside: shows a history of all previous search terms for possible reuse
• Yellow star: allows to define favorites that can be loaded for quick reuse. The context menu contains the menu items Add to favorites, Edit favorites and Favorites – the last item contains the saved favorites in a selectable list
• Green star and dot: can be selected as soon as the option Regular expressions is enabled and opens a list of regular expression options appropriate to the selected regular expression engine

Replace

If we move from the classic find function of text/code to the replace function, the basic functionality is retained, and in a simple sense is supplemented by a second string that replaces the search string. UltraEdit offers in the Replace tab the same basic functionality and extends it with the function buttons:

• Replace: replaces the string from the “Find what” section with the string from the “Replace with” section (keeps the Find and Replace dialog permanently open)
• Replace once: replaces the searched string from the “Find what” section with the string from the “Replace with” section once (closes the Find and Replace dialog afterwards)
• Replace all: replaces all occurrences of the searched string from the “Find what” section with the string from the “Replace with” section (keeps the Find and Replace dialog permanently open)

Figure 5: Find and replace dialog with the Replace function opened

You will also notice that a small black icon button with two arrows has been added to the “Replace with” section, which conveniently swaps the two strings of the “Find what” and “Replace with” sections. It has happened to me many times that I wanted to undo a replaced string, for which the undo function can of course also be used. Depending on the text/code, however, it may make sense to simply swap the two sections and then replace them again.

Also relevant for the replace function and always very helpful for me is the option Preserve case. This power function causes UltraEdit to match the case of the replace string with the case of the found string with the condition of multiple rules:

• if the word found is all lowercase, the replacement word will be all lowercase
• if the word found is all UPPERCASE, the replacement word will be all UPPERCASE
• if the word found is MixedCase, the replacement word will match the casing of the replacement word

We will illustrate this function with an example from the Delphi world. A corresponding click event is created for a button on a form and the procedure Button1Click is called as soon as the button is clicked. If we now enter “Button1Click” in the Find section and “ButtonActionClick” in the replace section, the following for all occurrences happens:

• “button1click” will be replaced with ”buttonactionclick”
• “BUTTON1CLICK“ will be replaced with ”BUTTONACTIONCLICK”
• ”Button1Click“ will be replaced with ”ButtonActionClick”

Find/Replace in Files

Now that we have talked in detail about finding and replacing in the currently open file/document, we come to the supreme discipline, namely finding and replacing in complete files and directories.

This functionality is already known from various IDEs (Integrated Development Environments), such as Microsoft Visual Studio and Embarcadero RAD Studio, where it is used to search projects or entire project groups across multiple files, folders, and even drives.

UltraEdit’s professionalism is now emphasized by providing this powerful feature of IDEs in a text editor, and we will take a closer look at it below:

Figure 6: Find and replace dialog with the Find in Files function opened

What is immediately noticeable here is the adjusted search focus in the In section, where the default setting is the “Files listed” option – this searches the files located in the two edit fields below, “In files/types” and “Directory”. While the directory field can accept a directory either in text form, via the “Use active file path” button or via the browse button next to it, the upper field “In files/types” can be used to specify either individual files or wildcards. Multiple entries are separated by a semicolon and 3 typical examples might look like this:

• *.pas;*.cpp
• Testfile.txt;*.cpp;*.h
• *.pas;TestForm.frm;*.dfm

In these examples, wildcards and named filenames are mixed, which UltraEdit can easily handle when the semicolon is used as a separator.

Further In section options are available for open files, favorite files (Application Menu -> Favorite Files) and project files – the latter searches all files within a currently open project. These three options ignore the edit fields “In files/types” and “Directory”, as these are only used with the “Files listed” option.

The Find button closes the Find and Replace dialog, the search is then performed and all results are displayed in the Output Window below. The respective files can be opened in the Output Window by double-clicking on the line with the file name. Anyone who is familiar with the Output Window will know that there are many more options available in a context menu via the right mouse button. These include collapsing/expanding the entire window content and copying the content to the clipboard.

Figure 7: Output Window with the results of the Find in Files search function

What is worth mentioning at this point, apart from the regular expressions (which we will come to at the end of this blog), are the interactive results.

When the Interactive results option is enabled, the Find in Files search will open a new Interactive results document. In this window all the Find in Files results are returned, but these results are immediately editable and the user doesn’t have to take intermediate steps to open matched files to edit the string that was searched for. This is effectively a window into the relevant portions of each matched file and the users may edit results individually as desired.

Figure 8: Interactive results window from the Find in Files function

If preferred and once the Interactive results document is opened, the user may switch to the Replace tab in the Find and Replace dialog. When focus is on the Interactive results document, the All open files option in the Replace dialog is dynamically changed to All results. If this option is selected, the user can use the replace operation interactively by pressing the Replace button, or uses Replace all to replace all matched strings in all files listed in the Interactive results document. When All results is selected in the Replace dialog, no other open files will be affected by the Replace all operation.

When direct editing of the results (either by typing or replace operations) are done, the user may close the Interactive results document. When the document is closed, a prompt appears asking whether the changes should be saved – changes would then be saved for all modified documents listed in the Interactive results document. This additional intermediate layer provides a clear way of keeping track of things, especially if there are many files that need to be changed.

The fourth major search function is Replace in Files, and here the Replace function is used in connection with listed files (names & wildcards as well as directories), favorite files or project files.

Figure 9: Find and replace dialog with the Replace in Files function opened

In the replace options, the user can include subdirectories, ignore certain hidden directories or file names/extensions and use the two options List changed files and Open matching files.

With the first option Open matching files is enabled, any files matching the specified parameters will be opened when the search completes. The second option List changed files instructs UltraEdit to list all the files that were modified in the Output Window. If enabled, each file change will be listed in the Output Window followed by the number of occurrences found and changed.

Regular expressions

Regular expressions have been widely used for many years and once you have understood the principle, you will never want to miss them again. In UltraEdit, the option to activate regular expressions is available in all 4 tabs of the Find and Replace dialog. Once activated, you can choose from 3 different expression types:

• Perl: UltraEdit uses Perl style regular expressions based on the Boost C++ Libraries
• UltraEdit: UltraEdit uses its own style regular expressions
• Unix: UltraEdit uses Unix style regular expressions.

Regular expressions are search strings where certain characters (symbols) have a special meaning. The following symbols and associated functions exist in the original UltraEdit syntax:

These symbols and associated functions result in many examples, some of which are described below to give you an idea of how they are used:

m?n matches “man”, “men”, “min” but not “moon”

t*t matches “test”, “tonight” and “tea time” (the “tea t” portion) but not “tea
time” (newline between “tea ” and “time”).

Te+st matches “test”, “teest”, “teeeest” etc. but does not match “tst”

[aeiou] matches every lowercase vowel

[,.?] matches a literal “,”, “.” or “?”

[0-9a-z] matches any digit, or lowercase letter

[~0-9] matches any character except a digit (~ means not the following)

The user can search for an expression A or B as follows:

“^{John^}^{Tom^}”

This will search for an occurrence of John or Tom – there should be nothing between the two expressions.

 The user can combine A or B and C or D in the same search as follows:

“^{John^}^{Tom^} ^{Smith^}^{Jones^}”

This will search for John or Tom followed by Smith or Jones.

Summary

UltraEdit offers flexible search and replace functions that work either for individual files/documents or complete directory structures. Countless options allow you to fine-tune the parameters and leave almost nothing to be desired. UltraEdit thus takes the step forward of providing much more powerful functions than many users are used from a text editor. As a result of these options, productivity is increased and search and replace is as powerful as the user works with this functionality – this blog provides the necessary know-how for this.

If you’re looking for a versatile text editor with powerful find and replace functionality, you can rely on UltraEdit. Download it now and try it for 30 days for free.

Try UltraEdit

The post Master UltraEdit’s Flexible Search Functions appeared first on UltraEdit.

Column Mode is an often-unknown feature of UltraEdit for many users, and experience has shown that those who have become familiar with it no longer want to go without it.

This powerful feature changes the way in which UltraEdit selects and edits text. Normally this is done horizontally from character to character, and Column Mode changes this mechanism to vertical processing.

This mode is activated program-wide via the keyboard shortcut Alt + C and can be activated simultaneously via Edit -> Column / block (Ribbon mode), Edit -> Column mode (Contemporary menu mode) or Column -> Column mode (Traditional menu mode):

For further understanding, we will use a simple example with a text file consisting of 3 columns and 10 lines. Once activated, UltraEdit will highlight the text based on the column position of the first character the user selects to the column of the last character he selects. Text selected in column mode does not automatically include all text between the start and end position, but does include all text in the columns between the first and last character which is selected.

Assuming we would like to insert text before the second column, the position in the column and for the desired rows is marked so that we find the marker seen in the following first figure. This simple marker does not select a character or word, but a simple vertical position. By entering new text, e.g. the word “My “ this is now done across all selected lines (see the following second figure):

UltraEdit allows the user to specify the font to be used in Column Mode separately. This font is selected via View -> Fonts -> Set hex / column font (Ribbon mode and Contemporary menu mode) or View -> Set hex / column font (Traditional menu mode).

Pro tip: if fast editing without prior separate activation of the Column Mode is important, the Quick Column Mode is a good option. The same column selection can also be used via Alt + Click-n-drag, which automatically activates Column Mode. Column mode is then deactivated as soon as the cursor is repositioned.

Basically, there are 3 functions for editing columns, described in more detail below. The Insert / fill columns function can be used to enter text that is inserted into a special column. If several rows are selected, the text is entered in these selected rows. If no lines are selected, text is entered for all lines in the file. The dialog Insert/Fill Columns appears for this, in which the text is entered. The lower option is called Do not insert / fill on empty last line and prevents this text from being inserted in the last line of the file if this line is empty.

The further options Cut columns and Delete columns open a separate dialog in which the number of columns to cut/delete from every line staring at the current line and the current column can be specified (0 means to cut/delete columns based on highlighted text).

By using the justify options for left, center and right the user can justify a selected column of data, with the boundaries of the selection acting as the margins. Left-justifying a column of data will justify the data against the left of your selection, while right-justifying will do the opposite. Center-justifying the column of data will center the data within the selection.

As soon as any kind of line numbering is required, the Insert Number function is quite useful, which opens the dialog of the same name. Various options can be defined in this dialog:

• First number: describes the first starting number for the
  counting
• Increment: defines the steps in which the number is to be
  increased
• Leading zeros: determines whether shorter numbers are
  padded with leading zeros to match the longest
  number (such as 001 to 100)
• Do not insert / fill on empty last line: prevents the
  numbering in the last line if it is empty
• Format: allows a distinction between decimal or
  hexadecimal notation.

If we use our original Column Mode example from the beginning and want to insert a number before each row, we select rows 1 to 10 in the first column, open the Insert Numbers dialog and press Insert at the bottom. We could also subsequently insert a space after the rows or a dot, depending on the requirements:

Please note: In our Column Mode example, we indeed have an 11th empty line, so it would make sense to enable the option Do not insert / fill on empty last line inside the Insert Numbers dialog.

If we use our original Column Mode example from the beginning and want to insert a number before each row, we select rows 1 to 10 in the first column, open the Insert Numbers dialog and press Insert at the bottom. We could also subsequently insert a space after the rows or a dot, depending on the requirements:

Please note: In our Column Mode example, we indeed have an 11th empty line, so it would make sense to enable the option Do not insert / fill on empty last line inside the Insert Numbers dialog.

The Sum function can be used to convert selected text areas into digits and add them up to a total. To do this, the user can select the area in Column mode, then select the Sum selection function and the Sum Selected Text dialog appears:

• Ignore character in number: because some number formats contain non-digits characters, such as commas, dots or dashes, these characters can be ignored – leaving only the pure digits for the sum
• Use locale: uses the Windows locale for the thousand separator, e.g. “,” or “.”
• Total: contains the final result of the sum function
• Copy to Clipboard: copies the sum to the clipboard
• Help: opens the UltraEdit Online help system.

In our example above, we have selected the numbers added via the Insert Number function at the beginning of the line, and these are the line numbers 01 to 10. The sum of these line numbers is then 55, as calculated correctly by UltraEdit.

Another great strength of Column Mode is the handling of CSV files. These text files, known as Comma-Separated Values, are often used for lists, whereby several columns are separated from each other by a separator character (often a semicolon). Many spreadsheet programs allow tables to be saved and exported in this format. However, editing these files where column manipulation is required can be difficult because the column widths vary and do not have a fixed size. UltraEdit therefore has two functions that convert a CSV file to a file with a fixed column width and the reverse process via a conversion to a CSV file.

The first function is called Convert to fixed-width and opens the dialog Convert to Fixed Columns:

In this dialogue, the user can define the properties before UltraEdit analyzes the file content with the Scan button and finally converts it with the Convert button:

• Scan first line only (vs. complete file): instructs UltraEdit to search just the first line for the field widths
• Keep delimiter with fixed columns: means that when converting to fixed width columns the delimiter character for the fields will not be removed. If this option is disabled, the conversion process will remove the delimiter between fields
• Ignore separator in quotes (‘): if enabled, separator characters which are enclosed in single quotes will not be taken into account when scanning to determine column spacing for alignment
• Ignore separator in double quotes (“): this option is identical to the previous option, except that double quotes are taken into account instead of single quotes
• Separator character (^t for tab): defines the delimiter character between fields (for the TAB character “^t” should be used). In all other cases, a single character should be entered and UltraEdit uses this character to determine the field boundaries
• Field widths (separated by commas ‘, ‘): represents a list of comma-separated field widths used for the conversion process. If there are more fields than entries, the last entry will be used as the field width for the remaining fields, which allows the user to set a single entry, if all fields are required to be the same width. Please note, that this field must not be left empty when the conversion to fixed columns is executed. It may be populated automatically by pressing the Scan button after specifying the conversion options, or the user may manually specify field widths if desired
• Scan: UltraEdit scans the file (or first line) and determines the maximum field widths for each field. This will determine the maximum width required for each field and place the results (comma separated) in the Field widths edit field.
• Convert: performs the conversion from character delimited text to fixed column according to the defined settings – the complete file will be converted.

The opposite can be performed with the Convert fixed-width to CSV function, which opens the Convert to “Characters Delimited” text dialog:

• Separator character (^t for tab): defines the delimiter character between fields (for the TAB character “^t” should be used). In all other cases, a single character should be entered and UltraEdit uses this character to determine the field boundaries
• Field widths (separated by commas ‘, ‘): represents a list of comma-separated field widths used for the conversion process. If there are more fields than entries, the last entry will be used as the field width for the remaining fields, which allows the user to set a single entry, if all fields are required to be the same width
• Convert: performs the conversion from fixed column to character delimited text according to the defined settings – the complete file will be converted.

Configuration of Column Mode

The performance of a function essentially depends on its flexibility and configurability, and here UltraEdit offers fine-grained settings. These can be opened either via Advanced -> Settings (Ribbon mode), via Advanced -> Configuration (Traditional menu mode) or via Advanced -> Settings (Contemporary menu mode). All three options open the Configuration dialog, in which all settings are contained in a central location. Within this dialog, the user needs to navigate to the category Editor -> Column mode to open the options for Column Mode:

• Overstrike: handles the overstrike in Column mode and under which circumstances the overstrike is prevented:
  • No overstrike of unselected columns: should be selected, if the user never wants overstrike mode to be used with column operations
  • Overstrike if in overstrike mode: means that the column operations operate either in insert mode (as default) or overstrike/overpaste mode based on the insert/overstrike keyboard setting. This is toggled by the Insert Key and shows up on the UltraEdit status bar. If in overstrike mode, cut/delete operations will remove the contents but leave spaces so that column data is not shifted. Paste operations will paste over the current position data and not shift columns either
  • Always overstrike unselected columns: should be selected, if overstrike mode is required permanently for column mode. 
• Automatically populate sort fields when in column mode: controls the behavior of selected text in column mode. If this option is enabled, in that case the column values for the current selection will be used to automatically populate sort fields in the Advanced Sort/Option dialog when the Sort function is invoked
• Paste into all selected columns when clipboard contains less than 1 line: by using this option and when a multi-line selection exists in column mode, a single string copied to the clipboard will paste to all selected lines. If this option is disabled, the column mode paste would only apply to the first selected line.

Two practical examples for the Column Mode:

Finally, we would like to describe two practical scenarios that can be used to understand the performance of the Column Mode. Even if the following two scenarios appear relatively compact, these options should always be considered on a larger scale. A realistic question would be: how much time and effort would I save if I had to edit not just a 10-line log file, but a 1,000,000-line log file?

Scenario 1:

For this first scenario, we have Delphi source code, and as can be seen in the following upper left figure, the procedure Button1Click is shown, which describes those activities as soon as the button with the name Button1 is pressed. We now extend the source code with a so-called if-then query, which describes a coherent code action with a subsequent begin, that is terminated again with end; (in the following upper right figure). This begin-end block is usually indented two positions to the right, which favors a more structured syntax. We therefore activate the UltraEdit column mode and first mark the lines to be indented at the respective position (please see the following lower left figure). If we now insert a space twice with this positioning, the entire selected block is indented to the right and we have achieved our result (please see the following lower right figure):

Pro tip: The same method can also be used to comment out a code block of any size by entering the two characters // instead of 2 spaces. In Object Pascal and C++, this means that the respective line is commented out, which is then applied to the entire selected block in column mode.

Scenario 2:

In this second scenario, we use a log file, as they exist in many IT sectors; UltraEdit is known for processing extremely large files. Our log file consists of 4 columns and 11 lines, of which the first line is the header. The columns are named Number, Date, Owner and Value:

First, we want to use the Sum selection function and therefore activate the Column Mode, select the Value column in lines 2-11 (without the header row), and select Sum selection (e.g. from the Edit -> Column / block tab in Ribbon mode). The Sum Selected Text dialog box then opens and the sum is displayed correctly in the Total field with 123450:

In the next step, we would like to replace the slashes in the date column with hyphens. A “01/09/2024” should therefore become a “01-09-2024”. To do this, we select the first slash column in column 2 within rows 2-11 (without the header row) as seen in the following top figure and activate overstrike mode by entering a hyphen. This means that the slash in all selected rows is overwritten by a hyphen. We repeat the same process in the second position of the slash so that we achieve a result as shown in the following bottom figure:

Summary:

UltraEdit’s Column Mode is a powerful feature for editing text and source code in a new way than was previously possible. Combined with the flexibility and processing of extremely large files, even gigabyte-sized log files can be edited vertically.

Additional functions allow the handling of new/existing columns, the change of alignment (left/center/right), the flexible insertion of numbers, a sum function as well as the conversion to and from CSV files with variable column width to a fixed column width and vice versa.

Column mode can be further configured in the UltraEdit settings, and the experience with customers has shown that anyone who has got to know this function appreciates it and no longer wants to work without it. With this in mind, have fun boosting your productivity!

Learn more about column mode:

The post Practical use of UltraEdit’s powerful Column Mode appeared first on UltraEdit.

This release also brings fixes for commonly reported problems and bugs, and quality of life improvements to the features and workflows that need them most. All in all, we have a pretty hefty but varied release so we can hopefully provide benefits to most if not all of our users.

New “Start support request” command

Starting a support request automatically starts an email with your device details for convenience.

We’re starting 2024.1 with a new general feature that will help any of our users submit support emails to UltraEdit. A new command will now be available to make emailing us about functionality and product-related concerns easier.

To execute, you click the new command and it starts an email using your default email client. This email comes prepopulated with pertinent information such as program version, basic system and user information, and the like. 

This automatically fills in data that are usually relevant to support requests. This makes the overall support process smoother, which in turn quickens the delivery of fixes and changes as well.

Enhanced XML manager editing for attributes and values

For those using UltraEdit to view XML files, you can now also make changes to attribute values in the XML manager. 

While browsing the XML manager, and you see something you want to edit, you can now jump into this attribute value table and you can actually make a change.

This is the first of many possible changes planned for making XML use easier in UltraEdit.  For instance, if you have any suggestions on what else we should do for XML view, let us know.

New horizontal split view for Live Preview

Apart from the regular view where it’s split left and right, you can have live preview split horizontally.

A new addition to live preview added in this release is the ability to change the orientation of the live preview pane. This new feature allows you to view renderable files in horizontal fashion (as opposed to just the default vertical view.)

Access this new option under Coding Tab → Live Preview and select which orientation you would like to use.

New remote file upload/download progress bar in application status bar

New download status bar for FTP and cloud transfers.

In UltraEdit 2024.0, we added cloud storage support inside the editor. This made it easier to manage files across your local device and your cloud storage drives. After general availability, a number of users made  requests to add a progress bar to signify the status of file downloads. 

With this change it is now easier to see whether your files have finished downloading, or to see what percentage has been downloaded. 

This new status bar also works for file transfers using FTP protocols.

Compare Tool Improvements

There are multiple changes in this release aimed at making compares easier and better. These were based on the most popular user requests. Take a look at them below.

Compare tool configuration UI added to support any compare utility

Navigate to the Integrated applications tab and go to Compare tool. Specify the compare tool you want to directly access from UltraEdit.

This new command allows you to specify a third party compare tool and allows you to launch that tool easily. (This is if for some reason you prefer not to use the already integrated UltraCompare.)

To use this, navigate to the configuration window and click the check box under Integrations → Compare Tools. Input the path to the compare tool and the next time you execute a compare, it will use the new tool you have specified.

New compare file command added to file tab menu for easy access

Furthermore, to make executing compares between files easier, we’ve added an easier-to-access option under the File Tab. 

A new way access file compare is now available under the File tab.

Improved readability and usability of compare settings dialog

When doing compares, you can now drag the corner of the windows to increase its size. This improves how the compare dialog is shown. 

This change was motivated by quality of life requests from users who had long file directories. This change allows them to quickly see the whole file path without having to scroll through the entire text.

To access the compare dialog menu, click on the Compare tab on the home screen.

Quality of life improvements

We’ve categorized the following items as QoL changes. These can be either small changes or new features aimed at making usage and handling of the editor features a lot better.

Enabled horizontal scrolling using devices and gestures 

A new way of adjusting your view in UltraEdit has been added. if your opened file is horizontally long, for instance, in database files with numerous columns, you can now use other ways other than moving the caret with your keyboard or manually dragging the scroll bar with a cursor.

As of UE 2024.1, the following methods of scrolling will work for almost all devices and platforms supporting gestures such as:

• Secondary mouse wheel (left and right)
• Trackpads
• Preset gestures & scrubbing
• Custom keybinds and similar navigation devices.

This feature is enabled by default and you don’t have to set anything up. If there are other devices you would like to see supported, send us a message.

Protip: Try this feature out in combination with column mode—another powerful tool when it comes to dealing with large seas of text and data. 

New URL highlighting options and open URL commands

• New underline setting for URLs instead of highlighting

This simple change allows users to choose whether to highlight or underline text recognized as URLs. Change this setting by opening the configurations menu and under Editor → Advanced.

• New command to launch and compose emails

Similar to how you can open hyperlinks directly from inside the editor, you can now click on email addresses in the editor. Use the command Ctrl + Shift + Click on an email address and your default email client will open with the recipient address filled in.

Automatically recover previously open files after a crash without a prompt 

When UltraEdit crashes or closes unexpectedly (i.e. power outages, fatal errors, etc.), there is a prompt for the user asking if they want to recover the last saved or auto-saved version of the file. 

Users have requested for a way to automatically recover files without having to go through the prompt. We’ve added a new checkbox  in the popup so users can save their preference and automatically recover files should the unfortunate need arise.

Full cloud storage support in FTP Browser

In UE 2024.0, we’ve added cloud storage capability to UltraEdit. A little earlier than that, we’ve added the same to UFTP 2023.0. 

You may wonder why this hasn’t been in the integrated FTP browser inside UltraEdit. Well, that’s what we’ve added in this release. Starting from this release, the FTP browser will now work like its standalone counterpart: you can now find, move, and access your files in the cloud in the UltraEdit FTP browser. 

Other notable  improvements and changes:

Here is a list of other minor fixes and quality-of-life improvements based upon user reports and requests. If you have any questions or suggestions, please mail them to support@ultraedit.com.

• Improved code folding support for ASP code
• Improved positioning and selection range for “active line highlighting for wrapped lines
• Addressed selection issues with specific search ranges and EOF conditions
• Resolved discrepancies with differing search count results from different search features
• Addressed dialog control enable/disable state discrepancies with user tool configuration dialog
• Corrected negative column number display for certain HTML files
• Addressed multiple issues with display and editing with non-English text, code pages, and encodings
• Resolved multiple issues with tab settings and tab displays
• Resolved multiple printing issues with indentation, positioning, and wrapping 

What’s Next for UltraEdit?

In the last update, we mentioned how we wanted to depart from having a big dot release on the first version of the year and instead have more frequent bundles of smaller improvements.

The main impetus for that change was the allowance of more flexibility and more time for developing bigger features while at the same time being able to deliver important and timely updates and fixes. UE will most likely follow the same update format for the following updates.

This release has a lot of small tweaks but ironically is one of the biggest releases we had in a long time. User requests were at the forefront of the decision making for what was included in the release so we hope that most if not all of these changes will bring you some benefit in using UltraEdit.

You’ve reached the end of UE 2024.1 updates. But check out our August bulletin for a more comprehensive look at what’s coming for UltraEdit!

The post UltraEdit 2024.1 release blog appeared first on UltraEdit.

Read on further to check out what’s coming for UltraEdit in August and September. 

Dev Days of Summer Code Camp

Join us as we co-host the Dev Days of Summer Code Camp. The event is two weeks long and consists of live and on-demand developer content, all completely for free.

Enjoy a free platform for skill sharing and collaboration with some of the best developers and industry experts from a wide variety of coding disciplines. This event is open to all developers of all skill levels. We strongly encourage beginners and experienced developers alike to participate..

Here’s what you can expect from the event:

• Explore Diverse Topics: Join discussions on a wide range of subjects from cutting-edge tech to foundational programming skills in  our webinars.
• Interactive Sessions: Engage in Q&A sessions, hands-on tutorials, and collaborative projects with developer teams and experts.
• Network and Grow: Connect with fellow developers, share experiences, and build lasting relationships.

Coming soon: UltraEdit 2024.1

Once you’re done signing up for the event, you can check out this preview of an upcoming update  to UltraEdit/UEStudio. This update is coming this month and it will feature numerous bug fixes and even more quality-of-life changes. 

These were all carefully curated and chosen from the most popular user requests.  Similar to previous releases,  this will feature several small but beneficial improvements that are useful for a majority of users.

Here’s a sneak preview of what’s coming:

• A more streamlined support request submission system
• New supported gestures for mouse, trackpad, and other pointing devices
• Support for third party compare tool integration
• And a lot more!*

*There really is a lot more but we can’t share everything here yet. You just have to keep posted for the announcement blog post. Sign up for our newsletter so you don’t miss anything!

Teaser: Big development coming for UltraCompare!

Our next announcement is related not to UltraEdit but to its sister tool, UltraCompare.

For you keen eyed readers, you would notice in the previous section how we mentioned UltraEdit will add support for soft integration of third party compare tools—that is if for whatever reason you don’t like the already integrated UltraCompare!

But for those of you who can’t get enough of UltraCompare, even when you’re on other programs or apps… great news! In a few weeks, UltraCompare will start the pre-release for integration on a popular IDE program. (Hint: It’s a popular Windows IDE.)

The idea here is to introduce UltraCompare as a plugin for the IDE so you can do compares and merges right inside the program window—much like how you do inside UltraEdit. We’ll start off with basic features most likely but stay tuned for more developments!

Update to UltraEdit Academic Licensing

When you start off your career as a software developer, data analyst, or amateur coder, you most likely started off with a normal text editor for basic coding projects. And while that’s completely fine, wouldn’t you prefer having something as powerful and versatile as UltraEdit right off the bat?

UltraEdit has granted 50% sponsorship for students, teachers, and teaching departments. This allows young learners to fully experience tools and start practicing on professional-grade tools used in the industry.

Starting from August 17, UltraEdit will fully sponsor licenses for individual students and learners. This includes but is not limited to: high school students, university students, self-taught coders enrolled with valid educational email addresses, etc. 

Please visit our academic page when the program is live for more information.

Summary

Many exciting developments are coming to UltraEdit in this month of August (and September too! But we’re saving that for the next blog post). Please check back on our website and on our blog to keep up with the latest news. 

If you have any questions or suggestions, please reach out to us using our support address. 

The post UltraEdit Bulletin: Getting ready for August appeared first on UltraEdit.

Click here to download the new version.

Cloud storage integration

With cloud integration, you can get rid of productivity-crippling interruptions and search for files directly inside a window dialog in the editor. 

This is particularly helpful if you have multiple cloud accounts or if you haven’t mounted all your cloud profiles in your desktop. With this new feature, you can use the UltraEdit dialog as a hub to search all your files from any supported cloud service.

The following cloud storage services are available:

• Google Drive
• Microsoft OneDrive
• Amazon S3
• Dropbox

Application scripting additions

• New document properties

These set of new scripting parameters help you determine certain document properties for use in scripts. This includes certain properties such as when the document was created or modified or accessed, you want to know what the attributes of that document are.

Here is the list of new properties added in UE 2024.0:

• dateCreated
• dateModified
• dateAccessed
• fileAttributes
• owner
• syntaxHighlighting
• characters
• lines
• nonEmptyLines
• sLOC
• averageLineLength
• longestLine
• changedLines

• readText/writeText functions & getEnvironmentVariable function

There are also added improvements for properties and elements beyond the domain of the editor. This is for when you want to check for certain properties or parameters that are outside the opened file, you can use the following functions.

For example, you may want to know who owns the file, or what type of syntax highlighting is used. With these new functions you can adjust your scripting to discriminate various traits.

Scripting documentation.

LEARN MORE: For a complete list of existing functions and scripting you can visit Help in the editor. Alternatively, you can read this online documentation conveniently located in a Google doc. 🙂

Access the help menu in top right of application window, next to Support menu.

Updated standards for dockable window for SSH/Telnet 

For SSH/Telnet users and systems administrators, great news! UE 2024.0 brings more modern encryption and connection standards.

This comes at the heel of multiple user requests asking for bug fixes and QoL improvements. Alongside the fixes, the console has been updated to be on par with the latest industry standards and conventions for encryption and connection. The following have been added:

• Support for key agents
• Latest encryption standards

UltraEdit’s SSH console will now use SSH key agents, if present, when logging in to SSH hosts. A key agent centralizes and simplifies public/private key management by loading keys and prompting for required passphrases. Once loaded the keys can be used by any application that supports the key agent protocol.

It now leverages industry standard OpenSSH tools, included with Microsoft Windows, to support the latest encryption standards while also ensuring timely security and protocol updates.

Support has also been added for user specified custom settings and parameters providing access to the full set of OpenSSH configuration options, including SSH forwarding.

What’s Next for UltraEdit?

Historically, the first UltraEdit update of the year is a more condensed package that gives the foresight of where the updates will go for the rest of the year. (e.g. previous years had a theme around augmenting large file handling or the scripting SDK setup)

This release will mark a departure from that concept. UE’s product development will utilize smaller bundled but more frequent updates. This allows more flexibility and more timely improvements to be delivered—not necessarily at the expense of the overall work done in the editor year over year.

What does this mean to you? Well, for one thing, the development team will be more receptive to your feature requests and you can expect shorter wait times for simpler requests to make their way into the next release.

You’ve reached the end of UE 2024.0 updates. But we’re expecting the fruition of some of our foundational changes from last year to come incrementally—some are in the editor already!

Fixes and improvements

Apart from new features, this release has a lot of maintenance and improvement items. Here is a list of fixes and quality-of-life improvements based upon user reports and requests. If you have any questions or suggestions, please mail them to support@ultraedit.com.

• Honor Windows setting to hide cursor (mouse pointer) while typing
• Allow sorting by clicking on the column headers in the Windows dialog
• Add “Copy” button to Sum Selection dialog for total value
• Sum selection returns incorrect negative value
• Add link to main downloads page in Support menu
• Add ability to run PowerShell script from context menu in Project or File View
• Add “New script” as default PowerShell template
• Default language for syntax highlighting is changed if new wordfiles are added
• Second instead of first configuration item selected on using Find in Configuration
• Display issues with Manage Themes dialog on Windows 11 at 175% scaling and UHD resolutions
• Clipped labels in Modify Templates/Modify Groups dialogs at 125% scaling
• File extension based font setting is ignored
• URL selection is incorrect in Markdown file
• Default Template fails to appear, after closing and reopening the file
• Renaming a file is not reflected in file lists
• Creating a new template with the same existing template name
• “New script” default template does not appear for all applicable template groups
• UI elements not clearly visible after resizing Modify Templates dialog

Download UE 2024.0

The post UltraEdit 2024.0 release post appeared first on UltraEdit.

Almost exactly 30 years ago, UltraEdit’s original author Ian Mead introduced his new Windows text editor – at that time, a side project named MEDIT – to an online CompuServe software library with little more than faith and hope for its future. (You can still read his original inspiring story here). 

In the burgeoning software industry of the 90s, UltraEdit found quick adoption with both individuals and larger companies for its reputation as a performant, versatile, and trustworthy text editor – something that still holds true today. For many users, UltraEdit’s ability to open large files of any size thanks to its novel disk-based approach to editing was (and still is) compelling enough to make UltraEdit the editor of choice for engineers, teams, and even entire corporations.

Initially introduced as a 16-bit application for Windows 3.1, UltraEdit kept lockstep with technology with the release of a 32-bit counterpart for Windows NT/95 and adopting a “-32” suffix to distinguish the two versions. Several years later, a 64-bit version would follow and is now the standard version in use.

As UltraEdit continued to grow in popularity, Ian recognized the need to build a team and organization that could service the many aspects of the growing product. This entailed many hires for various roles across engineering, QA, customer support, and marketing, as well as a partner and vice president, Richard Knott, to help steer the vision for UltraEdit. Believe it or not, UltraEdit’s first hire, Troy Pennington, is still with us today as QA and Support Manager!

These three decades have seen some major milestones: we released UEStudio, a version of UltraEdit with additional developer power tools. We brought UltraEdit’s sister product UltraCompare to market, as well as several other products including UltraSentry (now EOL’d), UltraFinder, and UltraFTP. We stepped into the Mac and Linux space with multi-platform offerings of UltraEdit and UltraCompare. We celebrated our one millionth user…now, many times that. We heard from customers about how our products were being used in NASA’s Mars rover program, genetic sequencing in the human genome project, and many other fascinating scientific and technical projects.

Throughout the journey, we’ve steadfastly centered on our “north star” instilled by our founder years ago: always do what’s right for the customer. And while interpretations of “right” may have varied, what hasn’t changed is our commitment to actively listen and promptly respond to your valuable feedback in service of that core value.

That brings me to the very best part of this 30-year celebration: you. I am extremely grateful for our loyal customers who have helped us become what we are today. Many of our biggest product advancements and breakthroughs are thanks to you: your posts, your emails, your suggestions, and your willingness to work directly with us in understanding your unique needs and challenges. We embrace that spirit of cooperation and collaboration. It fuels us every day. For our part, there’s nothing more satisfying than hearing from a delighted user who’s solved a unique challenge with our “Swiss Army Knife” text editor. 

So while there have been many transformative changes over these years, including a transition to new ownership, our mission and vision remain unchanged. Our team is still largely intact…and growing! Our core values established by our founder 30 years ago still guide us. We’re excited about what the future holds for our products and our customers (stay tuned!). We will continue talking to you about the problems you’re facing in your daily work and what we can do to help you solve them. And we will continue doing what’s right for you, because if we’ve learned anything through this journey, it’s that if we take care of our users first everything else will follow. Thirty years of text editing excellence and success have proven it.

We hope you enjoy the 30th major release of UltraEdit in v2024.0. And thank you again for an amazing three decades. Here’s to three more! 🥂

The post 30 Years of UltraEdit appeared first on UltraEdit.

Hexadecimal notation, commonly referred to as hex, serves as a cornerstone of modern technology. It is a numbering system with a base of 16 that uses 16 symbols to represent values from 0 to 15. It includes the standard symbols 0-9 and the letters A-F (or a-f) to represent values from ten to fifteen. Its presence is evident in various industry systems, including binary file formats, memory, and network addresses.

Moreover, hex plays a crucial role in encoding ASCII characters, streamlining the transmission of text data. Hex editors serve as essential utilities, empowering users to navigate and modify binary data efficiently. 

In a nutshell, hex editors are indispensable for navigating the digital landscape, enabling precise control and manipulation of data formats.

What are Hex Editors?

Hex editors are extensively utilized by programmers, security professionals, system administrators, and other tech-related professionals to view and edit binary data written in a hexadecimal format. 

Although similar to text editors that edit plain text data, hex editors are tailored for working with binary data. This allows developers and users to edit individual bytes of data present in a file. 

Additionally, there are files that cannot be edited in a text editor. If you’ve ever tried opening a file without the corresponding program that can read it (e.g. a random .dat file), your system may automatically default to using a simple text reader to try and open it. This opens a garbage file that is illegible and unusable—unless you use a hex editor.

Why are Hex Editors Necessary?

Hex editors provide users  access to the raw bytes that make up a file. Most of us who use text editors see user-friendly interfaces and texts that we can understand. However, behind the scenes are strings of binary values that are represented by text humans can understand.

Peeking through these binary values can help both developers and users alike to do the following:

• Troubleshoot and fix corrupted bytes of data

Corrupted data can stem from hardware malfunctions, software bugs, code tampering, and more. Its effect can be observed as data loss, crashes, or errors— affecting the productivity and utility of a system. 

Even the bytes of plain text files aren’t invulnerable against data corruption. Fortunately, hex editors offer users the ability to accurately locate and rectify corrupted bytes to their accurate values.

Note that the hex editor itself won’t tell you which byte(s) within the file is corrupted – you’ll need to know what to look for. But the hex editor provides a clear view into the bytes of the file so that you can easily do so, along with other tools like search/replace.

• Finding and removing non-printable / out-of-range characters in plain text files

Non-printable or out-of-range characters may sometimes be in plain text files. Depending on the program or use case, they may need to be removed to ensure data integrity, functionality, and human readability. Hex editors can read non-printable characters that can interfere with operations like searching, sorting, or parsing text.

• Data recovery

Being able to correct corrupted data, hex editors also allow users to recover lost data due to corrupted bytes. As mentioned previously this is achieved through inspecting and repairing binary data.

• Easier debugging process

Through hex editors, developers can inspect the embedded strings that are in executable files to further understand their structure. If you have enough prior knowledge, you can make targeted changes, fixing errors, or applying updates to compiled executables without access to the original source code

• Data modification and exploration

Hex editors are handy tools for exploring and tweaking file formats. By checking out how files are put together in binary, users can figure out how they work and adjust as needed. 

This could mean modifying game saves, modding games, adjusting settings in config files, or fixing up software files to make them work better.

Because you are editing specific bytes, you can alter certain executables with the proper know-how. Hex editors are commonly used to reverse engineer certain programs and executables because of how intricate it can be.

Limitations of hex editors

While extremely powerful and versatile, hex editors are not complete solutions. Editing singular files may not allow you the complete access you expect. For instance:

• You can copy and modify data—but without the program to properly read the file, you cannot execute it.
• You cannot bypass dependencies and third-party verification (digital certificates). In fact, altering even just a single byte in a digitally signed binary file will “break” the digital signature and introduce security issues if executed later.
• Some applications rely on multiple files and programs to run. Editing one file does not automatically translate to a workable file.
• You need some prior knowledge of when and where the relevant data starts. (How do you know where the “row data” starts and ends?)
• It may be overwhelming editing files of significant sizes using a hex editor. You may miss fundamental editing features such as those in text editors.

Considerations when picking a hex editor

There are many hex editors in the market ranging from free open-source software to paid ones. However, there are many things that you would like to consider before committing to buying one. Here are some of them:

1. Ease of use
2. Ancillary editing tools
3. Supported platforms
4. Security
5. Support and updates
6. Credibility

Recommended Tools for Working with Binary Files

When working with hex editors, you would most likely be using data manipulation techniques and features found in text editors. That is why some developers use both text editors and binary file editors for their work.

However, it may be tedious to switch between a text and hex editor repeatedly. UltraEdit stands out as a 2-in1 text and hex editor with higher software security standards. UltraEdit combines both text and hex editors, removing the need to run two separate programs to edit textual and binary data. 

Renowned for being able to open and edit extremely large files, UltraEdit’s optimized performance allows it to effortlessly handle any project, ensuring swift editing without compromising efficiency. 

Security and privacy are also one of its strengths. It comes with many security features including data encryption support, password protection, and regular security updates—features that you appreciate if you regularly work with sensitive data and binary files. 

Compatible across multiple operating systems, UltraEdit ensures seamless integration into your workflow. It only requires one license for Windows, Mac, and Linux; allowing users to utilize the editor using up to three machines on any platform. 

Apart from being a text and hex editor, UltraEdit is a multi-purpose editor that includes a text editor, HTML editor, XML/JSON viewer, and a hex editor, empowering users to tailor the editor to their specific needs. 

With UltraEdit, you’ll experience a smooth, secure, and productive editing experience, making it the ideal choice for professionals and enthusiasts alike.

Try UltraEdit text editor with Hex mode.

The post The Value of Hex Editors: Where they’re used appeared first on UltraEdit.

During the webinar you will:

• Understand the facts of non-compliance failure
• See how security-related problems can affect your company
• Learn how to protect your data when using text-editors
• Know the different industry practices UltraEdit use to protect users

This webinar is presented by Ian Barker (Developer Advocate).

This webinar has concluded. If you missed it, you could scroll down and watch the replay, skim through the highlights, and access the presentation slide.

Webinar Slides

 Replay

00:00:00 Start

00:02:30 Introduction

Ian introduced the concept of security breaches and their consequences. He then proceeded to provide viewers with a brief explanation on how UltraEdit protects users against data breaches, making them a harder target through the eyes of bad actors. 

00:04:12 It can happen to anyone

It is a common misconception that only major companies possess the risk against security breaches; however, most attacks are conducted against small businesses.

This section also contains data that shows the frequency of security attacks against US companies alone— a figure that can increase due to unreported or undetected breaches.

00:05:22 What does it cost

Ian explains how a security risk can potentially cost a business everything. Using data from 2020 to 2021, he then proceeded to show the severity of the penalty against non-compliance failures. Aside from being sued by individuals, there also exists the risk of fines under the jurisdiction of agencies and organizations such as the GDPR.

To further explain this, Ian shows 13 more links that state the cost of cybersecurity risks such as data theft and breaches.

00:12:42 But it’s “just a text editor”

Even text editors are vulnerable against data breaches and other threats and vulnerabilities. Data figures from 2018-2022 alone suggest that there were 3.26 million total complaints and around $27.6 Billion in total losses due to vulnerabilities in text editors.

That said, users should be aware of the threat looming behind the screen, especially when using open-source editors.

00:14:18 Security threats and vulnerabilities in text editors

This part of the webinar provides viewers with the possible problems that text editors may have behind the curtains. Ian then formulates various examples of text editor vulnerabilities consumers should be aware of.

From the abuse of third-party plugins to just plain developer negligence, there are multiple ways a malicious attack can be done on a seemingly safe text editor. 

00:21:14 So how do we stop it

Identifying and stopping security attacks before they happen is a crucial skill to have in the digital age. Ian started this section by giving importance to knowing that the threat to data security is real.

To prevent data attacks, users should be aware of a lot of things to ensure their data’s safety; however, this can be easily achieved by using UltraEdit.

00:38:38 How does UltraEdit stop it

Before releasing to consumers, UltraEdit undergoes secure coding practices, testing, and review that provide users with a worry-free experience. Furthermore, to ensure integrity, UltraEdit and its third-party component are scanned by Kiuwan SAST and Black Duck SCA respectively.

Ian also states the importance of your data, that’s why UltraEdit doesn’t send user data to cloud servers. UltraEdit also supports both online and offline license activation, SBOM requests, optional server connectivity, and more for a safer and seamless user experience.

00:45:57 What do we do to secure your editor and your data

In this part, Ian explains UltraEdit’s three-pronged methodology, editor support, and employed tools that makes the editor secure. If you’re curious on how UltraEdit protects your data, watching this section will fill you in with the details.

00:55:06 Q&A

Ian brings the webinar to an end and answers some questions from the viewers regarding UltraEdit.

Have any feedback or questions from this webinar? Send us a message with subject line “UltraEdit Security Feedback” in this address.

The post UltraEdit Masterclass: Are you accidentally leaving your security wide open? [Webinar Recap] appeared first on UltraEdit.

We’ve discussed in a previous blog why a tool as unassuming as a text editor also needs to be security-hardened in this day and age. In this blog, you can read on further to find out what tools UltraEdit uses to protect you and your data and what measures it employs to ensure its source code’s integrity.

Our Latest Additions to the UE Development Pipeline

UltraEdit is proud to announce that the source code and third-party components used in its underlying architecture are secured by state-of- the-art static application security testing tools (SAST) and source code analysis (SCA) tools.

UltraEdit recognizes that many individuals and businesses expect to be able to trust our tools with their most important and, often, confidential data. These security integrations represent a significant investment in meeting and exceeding those expectations. Hardening the security of our products to this level exemplifies our unwavering commitment to the integrity and protection of our users’ data and systems.

UltraEdit is primarily secured in three ways:

Why are these tools necessary?

UltraEdit stands alone in a crowded market of IDEs and editing tools when it comes to security. Our commitment to providing tools that not only exceed expectations in terms of functionality but also in terms of safety and security is unparalleled. One of UltraEdit’s priorities and edge over the competition lies in its ability to secure your digital assets by building a robust text editor built with security in mind—not as an afterthought. 

The industry-leading third-party tools we use provide ongoing comprehensive analysis and hardening of our codebase and serve as credible verification of the security of our applications. These tools help us identify critical issues and vulnerabilities before they ever ship.

Static application security testing (SAST) via Kiuwan

Kiuwan’s Static Application Security Testing (SAST) tool provides UltraEdit developers with several benefits: detecting security vulnerabilities in source code as they are written, enforcing the team’s coding guidelines, and flagging potential bug-prone elements in the source code.

Software composition analysis (SCA) via Black Duck

Blackduck by Synopsys is a software composition analysis (SCA) tool that UltraEdit uses to detect, manage, and secure its third-party source code components. This is an essential tool especially now that UltraEdit is adding its own plugin ecosystem.

UltraEdit’s Approach to Security: A Blend of Tools and Techniques

UltraEdit follows a three-pronged approach when it comes to security. This process involves internal checks, industry standard practices, and the utilization of software security tools. Each aspect of this approach filters out more surface areas and possible points of vulnerability in the software’s source code. 

Read on further to see how UltraEdit uses the latest additions to its toolset to help improve security.

• Manual and Peer Review

The first check comes in the form of manual peer review inside our development and engineering teams. Every edit or source code commit for any of our tools is inspected by a colleague before it is checked into source. Sharing written code also promotes transparency, early error detection, and collaboration, which are all essential for efficient software maintenance. 

It’s also the most accessible form of code protection; there’s no reason for a team or a company to not have a standard protocol involving manual peer review.

Keep in mind: Manual code review does have limitations, including the possibility of missing vulnerabilities due to human error or oversight. It’s also not easily scalable—something that might be of concern if you have multiple components or you’re dealing with multi-faceted source code applications.

In essence, though, this two-step manual process detects the most obvious errors and provides an avenue to ensure consistent coding standards. It’s also one of the easiest and most inexpensive options for securing source code; however, it must be augmented with other techniques such as automated testing.

• Static Application Security Testing (SAST) tools.

To address the limitations of manual review, software developers employ automated tools and techniques. Static Application Security Testing (SAST) tools are automatic quality control tools that complement manual code review. By combining manual review with suggestions from SAST tools, the overall security of source code is improved, helping to reduce the number of flaws that may slip into production.

These tools are used to evaluate source code without running or executing it—thus the term static. They examine the program’s structure and syntax to identify potential issues and errors, such as coding mistakes, security vulnerabilities, and performance bottlenecks.

UltraEdit uses a dedicated source code analysis tool (more on this later) to scan source code for possible vulnerabilities. These help detect issues that are laborious to check manually. This filters out common software errors such as obsolete programming techniques, memory leaks, buffer overflows, race conditions – things that can cause crashes or data corruption – and the like. It can even be fine-tuned according to UltraEdit’s own coding guidelines and conventions, which ensures better and faster development.

Keep in mind: While SAST tools cover a lot of ground in terms of curbing software vulnerabilities, it is not a catch-all solution. Because it lacks the ability to recognize context in the runtime environment, it may produce false positives, identifying issues that are not actual vulnerabilities, and false negatives. 

They are also often reserved for specific languages—meaning if you add components outside the supported code language, it may miss out on highlighting issues entirely. 

But overall, using automated tools greatly reduces development time as they can catch possible flaws early into a development cycle with minimal effort. They are also easy to use and are a great addition to manual peer review.

• Software Composition Analysis (SCA) tools

Similar to how SAST tools augment manual review, software composition analysis (SCA) tools can also cover some of the limitations of SAST tools. SCA tools are primarily used to analyze and manage the open-source elements of applications and software source code.

UltraEdit, like most modern software, has external dependencies. UltraEdit is not open source software but it does use open source components. This is one of the more crucial steps that not every publisher will take. This type of scan cross-verifies each and every line in UE’s open source dependencies with a database of known vulnerabilities maintained by security professionals. This database is continuously updated so that security issues can be detected and mitigated as part of the standard product build pipeline.

Many SCA tools also provide an automated inventory of all open source components within a software package, including those components version numbers. This information is often published publicly via something called a Software Bill of Materials (SBOM), a document that is now required by United States executive order for all federal software procurement.

Keep in mind: To properly work, SCA tools must rely on an up-to-date components database and list of known vulnerabilities. This means that obscure vendors or unpopular open source projects may sometimes take its time before it is identified properly. Developers must still exercise due diligence in choosing and maintaining the components they add to their source code.

However, SCA tools significantly reduce the time and effort required to track the provenance of libraries, plugins, and inherited components in your source code. This makes the SAST-SCA tool combo one of the most comprehensive security solutions available for software development. It vets most of the self-written code.

Threats and vulnerabilities in text editors

The FBI’s Internet Crime Complaint Center 2022 Internet Crime Report shows the trend of total cybercrime complaints they received contrasted against the amount of losses incurred.

Apart from the internal code that a team of developers writes, modern software is also built upon other pre-existing software and code. This makes it cheaper and faster to turn what would be a gargantuan development project into a more reasonable one-month sprint. However, this interdependent network of code also increases the scope of code that has to be secured and verified.

Even in a text editor—a usually unassuming piece of software—malicious actors may exploit security flaws due to the developers’ mistakes or due to inadvertent vulnerabilities embedded in the components of the source code.

• Security threats and vulnerabilities that can be present in a code or text editor include:
• Abuse of Third-Party Plugins: Security risks in popular extensible text editors that allow hackers to abuse plugins and escalate privileges on targeted systems
• Eval Injection: Improper neutralization of directives in dynamically evaluated code, which can lead to the execution of malicious code
• Broken Authentication: When authentication credentials are stolen, malicious actors can hijack user sessions and identities to impersonate the original user.
• SQL Injection: This can allow attackers to steal sensitive data, fake identities, and engage in various other malicious actions.
• Remote Takeover Vulnerabilities: Critical vulnerabilities in open source text editors that could allow attackers to remotely compromise a victim’s server and steal sensitive data
• Developer Negligence: Even without malicious actors, software may still become embedded with vulnerable components with security flaws if it gets published undetected.

Cybercrime takes on many forms: social engineering, network hacks, fraud, espionage, and a lot more. Each product or piece of software’s supply chain should theoretically be as fortified as possible. On the other hand, developer negligence and ignorance may also pose the same risks. Inadvertently using unverified source code and buggy, unreviewed code may bring as much harm as malicious actors.

The demand for extensibility has given birth to editor and IDE plugins—software components created by the open source community to solve each and every possible use case. Editor plugins and extensions provide exceptional flexibility and customizability to tailor to any user’s specific use case. (UltraEdit is adopting a modified version of this model.)

To mitigate these risks, it is important to use a combination of secure code review tools, regular testing during development, and monitoring and tracking repetitive issues. Secure code reviews can help identify and mitigate these vulnerabilities, ultimately strengthening the security of the code and text editors.

Looking forward: What to expect from UltraEdit

This blog post is meant to give you an idea about our approach to security and to share a bit about our two new security tools. There is no completely secure software available, period. But when it comes to security-hardened text editors, you can be sure that UltraEdit is one of the best (and maybe the only) choices available. Moving forward, UltraEdit will continue its endeavor to reinforce its security with the best industry practices.

Do you have specific use cases that need extra attention when it comes to security? The UltraEdit team is always looking for ways to improve the editor and its services. Send us a message detailing your use case, and we’ll make sure to consider it for the next release.

REGISTER NOW: Join our webinar on software security

The post Securing your software: How UltraEdit, a text editor, keeps your data safe appeared first on UltraEdit.

Back in the days of the nascent World Wide Web, I built my first website while in seventh grade on the then-popular website hosting platform Angelfire. I used Microsoft FrontPage to visually lay out tables and images, then uploaded via FTP the resultant HTML files it created to Angelfire’s server.

I recall discussing with a friend (whose skills far surpassed mine) how HTML tables were so important for HTML layouts and what the future might hold for web design. At some point he said to me, “Tables won’t matter soon – the new Cascading Style Sheets (CSS) features are going to make them obsolete. In fact, I do most of my layout and design now by editing CSS files directly in Notepad.”

While I refrained from showing my ignorance at the time, I remember incredulously thinking, “What?! Why in the world would anyone be using Windows Notepad to edit websites? Can you actually do that?” So began my journey of learning source code and editing plain text files.

Decades later, not much has changed in how our tech works. Underneath the many layers of abstraction and multiple steps of obfuscation, the internet – and the whole of technology in general – still runs on plain text files.

While our advances in software and computing since my middle school experience have been exponential – so exponential, in fact, that some students don’t know what files and folders are – if you want to harness the power of your computer, your smartphone, the internet, or some programming language to build and create, it’s essential to comprehensively understand the important plain text base layer that undergirds all our tech. Hence this blog post. Let’s take a deep dive into what plain text is, how to edit it, and how to choose a text editor that works for you.

What is a plain text file?

Understanding the “atoms” and “molecules” of computing

In grade school, we all learned that atoms comprise everything. (Now we know about subatomic particles, but for the purposes of this analogy, we’ll stick with atoms as our basic building block.) Bond those atoms together in certain ways, and you have molecules. Molecules are the basis of the natural world – from the air we breathe, to the food we eat, to our own bodies and their complex biological systems, to the materials used to build homes and skyscrapers…and everything in between.

This is somewhat oversimplified, but you can think of computing using a similar model. At the most basic level, computers speak in binary, i.e. 0s and 1s. “On” and “off”. “Yes” or “no.” These basic units are called “bits” (short for “binary units”), and they are the atoms of the computer world. Everything a computer is used for – video games, SMS messaging, space shuttle launches – it’s all composed of bits when you break it down to the lowest level.

Like an atom, a bit by itself isn’t very useful. However, like molecules, when you start arranging multiple bits in more complex structures, they become more useful. A “byte” in computing is a grouped arrangement of 8 bits, and bytes are akin to molecules in our analogy. And yes, this is what the “byte” in megabyte, gigabyte, terabyte, etc. refers to.

Like molecules, these bytes can then be arranged themselves to create more complex structures. For example, they can form the data used to display a JPG cat photo on your screen, they can be arranged to output the sound of your coworkers’ voices through your speakers, or they can be arranged in sequences that represent alphanumeric characters – what we call “plain text.”

Plain text files

So human-readable plain text files are, basically, arrangements of bytes that represent human-readable characters. The process of actually translating binary into human-readable text (from on/off bits, to bytes, then to plain text) is known as character encoding. Essentially, the computer system is pre-programmed with a “translator” that knows which byte (or sequence of bytes) represents which human readable character. That’s how the computer knows what to display on your screen when you open a text file. It’s kind of like using a decoder ring to decrypt an encoded message. For a deeper dive on this, check out our Unicode power tip.

Binary (non-plain-text) files

Now, something like a JPG file isn’t going to be human-readable because the computer’s translator for a JPG doesn’t translate bytes to plain text data. Instead, it translates bytes to pixel data which is then shown on your screen as an image. You need an image viewing program for that, which comes with its own pre-programmed translator for those types of “molecules” (bytes). 

You can open a JPG in a plain text editor, and while you’ll see letters and numbers, you’re not going to see anything that makes sense to humans. That’s because the computer is using the wrong translator for the byte data “language” in the JPG file. The same is true for Word Docs (they’re not plain text), PDFs, EXEs, DLLs, and many other data formats. We call these formats “binary”. (By the way, if you need to edit a binary file, check out UltraEdit’s hex editor!)

Opening a JPG image using a hex editor. This works because by encoding using hex notation, you can compress a longer binary string to save space.

Summary

In a nutshell, “bits” are the atoms of the computing world. When bits are arranged in groups of eight, it enables us to create different 8-bit combinations called “bytes,” which are the molecules of the computing world. These molecules can then be pieced together in meaningful ways inside of files to create all types of different “materials,” or data formats, that we can then use computers to translate to obtain information. One of those formats is plain text which can be used for creating source code files, log files, data and information storage, and a lot more.

How to edit plain text files?

Now that you have an understanding of what plain text is, you probably already know the answer to this question. You can edit plain text files with a text editor: a computer program that is designed to decode (read) and encode (write) plain text format. 

All operating systems include a plain text editor:

• Windows has Notepad
• MacOS has TextEdit
• Linux has many options…

To edit plain text files, open your OS’s text editor (or one you installed on your own) and simply open the plain text file you want to edit. It’s that simple.

iOS and Android don’t typically come prepackaged with text editors, but there are many robust third party Android text editors and iOS text editors available. iOS does include a minimal text editor for opening plain text files on your iPhone or iPad, but it leaves a lot to be desired, and you’ll quickly find yourself wanting something beyond its basic featureset.

Each type of editor comes with their own sets of benefits. For example, the native Windows Notepad may be enough for editing small plain text files but you would need a specialized editor like UltraEdit if you want to execute more complex text operations.

What is a text editor?

As defined above, a text editor is a computer application that is designed to decode and encode (or “read”) plain text format. A text editor is used to create, change, or edit plain text files.

Many people use text editors to open and modify plain text files like programming source code, config files (think JSON, XML, etc.), documentation (things like wiki markup and Markdown), log files, and much more.

Revisiting our atoms/molecules analogy, we established that plain text format is just one possible “material” that can be formed with “molecules” (bytes). A text editor is a tool that allows you to work directly with this material, allowing for a pure and straightforward connection with the digital fabric. No frills — just you and the plain text canvas. 

How does a text editor work?

Every character in a string has a corresponding value depending on the encoding format used. The graphic above uses ASCII values. Each value can then be represented as bits or bytes.

When you open a plain text file with a text editor, the editor retrieves the raw binary data (all those 0s and 1s) stored on your computer’s hard drive, then translates that into a human-readable format to display in the text editor. Here’s a bit more about how that process works:

1. You select the file to open. The editor accesses the file through your operating system and reads the binary data stored in the file.
2. The editor loads the binary data into memory and then interprets the bytes of the binary data as human-readable characters based on a specific encoding. There are many, many encodings, but only a few really popular ones that are used today (ASCII, UTF-8, UTF-16, etc.). The editor must determine which encoding is correct for the file, because if it doesn’t, your human-readable plain text will wind up looking like nonsensical garbage. There are several methods a text editor can use to determine the correct encoding, but that’s a more technical topic for another day.
3. Once the file is displayed in the text editor, the user (you) can begin making changes by typing into it, deleting existing text, cutting/copying/pasting, etc. Underneath the surface, the text editor adjusts the binary data accordingly. It’s like rearranging the atoms in our analogy to create new molecules.
4. When you save your changes, the text editor takes the modified text (usually stored in your computer’s memory) and translates it back into raw binary, then writes that data back to disk, overwriting the original version of the file.

What’s the difference between a free online text editor and a text editor download?

At the time of this writing, there are several options available for a free browser-based text editor. Many websites offer this functionality at no cost. These online editors offer some benefits, including access from any computer or OS and the ability to store your text files in the cloud.

For some, an online, browser-based text editor is a good choice and does the job. But for many users, continued use will eventually expose some significant drawbacks. So what are the advantages of installing a native text over using one in your browser?

Performance: Native text editors run faster, with less system resources.

You’re probably already aware that your browser consumes a LOT of memory – often, far more than many other applications running on your system. That includes native text editors as well. 

If editing plain text is something you’re doing quite often, or if you’re working with larger plain text files, or if you want to have many files open at once, you’ll likely prefer the less resource intensive performance of a natively installed text editor. For example, with a browser based editor, the more changes you make to your text, the more memory the browser needs to keep track of things like undo/redo. Also, because of the way a browser works, an online editor is likely going to work your CPU harder. And God forbid your browser crashes before you save your changes…

If you just need to make a one-off edit or even a few quick changes, an online text editor will probably be okay. Otherwise, you really should be working in a native text editor application.

Functionality: Native text editors can just do more.

Modern web applications that run in your browser have admittedly become more feature rich over time. But they won’t ever be able to approach the functionality that a native application can offer. Certain functionality like file system access to find and replace in files, file system exploring, window tiling and cascading, feature-rich file tabs and more simply aren’t possible in an online text editor. And while web applications can offer a breadth of functionality, that functionality often doesn’t go very deep, leading to frustrating dead-ends when you’re trying to accomplish more in-depth or complex tasks.

Offline availability: For when you’re not connected to the internet.

These days, access to the internet is like access to air – we take for granted that it will always be available. And usually, that’s the case. But in those rare instances where there’s a service disruption or you’re out of WiFi range, it’s nice to have tools that are still fully functional. If you rely upon an internet connection to use your editor, you incur a potential point of failure that you wouldn’t otherwise have with a native text editor.

Configurability: Native text editors can be customized to a greater degree.

Online text editors do provide a level of customization and configuration, however most don’t come close to the flexibility of native tools. Many native text editors offer options – key mapping customization, for example – that are OS-specific or otherwise aren’t possible in the limited browser environment. Furthermore, you likely won’t find plugins or extensions available for online editors, whereas these are ubiquitous with most native text editors. 

You might find that an online text editor suits your basic preferences to a degree, but if you continue to work seriously with one, you’ll inevitably hit a limitation in customization or preferences that likely isn’t there with native editors.

Privacy: Your plain text files remain on your local hard drive.

When you open any file or paste any text into an online text editor, that data is going to someone else’s server. Even if the site claims that data accessed in its web application isn’t collected or stored (or is stored but is encrypted) there’s no way to truly verify this without access to the server and application itself. The general rule of thumb is don’t put anything on the internet that you wouldn’t want someone else to see or have.

While cloud storage is beneficial and has its applications, for private, sensitive, or valuable data you need a local editor. That’s the only way to ensure your data stays safe, private, and secure.

OS Integration: Native text editors integrate with your operating system.

Natively installed applications can integrate deeply with your operating system – and other installed applications – whereas online text editors can’t. For example, dragging-and-dropping selected files into an app to open them, associating file extensions to open in certain applications, launching apps from the file explorer context menu, invoking a program from a command line…these are all ways that native text editors can integrate with your OS-native workflow that browser based editors can’t.

If you’re doing any sort of meaningful editing or code development, chances are you’re working a lot with different files, applications, and services all installed locally into your operating system. It doesn’t make much sense to circumvent that cohesive environment for a less integrated experience with general editing tasks. 

Can a text editor run code?

By definition, a text editor itself cannot run your plain text source code. It’s simply an editing tool. However, many editors can launch internal or external tools and processes (like interpreters and compilers) to run the code that you write. How this works is often unique to the source language you’re using.

It’s important to keep in mind that not all code works the same. Some code is open source, like HTML and CSS, meaning it’s delivered to the end user in its code format. The end user then uses their own tool (like a web browser) which makes the code useful.

Other source code is interpreted, which means it must be processed and run by some third party program. For example, Python code is sent to a Python interpreter program which then executes the instructions in the code. 

And of course, a lot of source code is compiled. This is similar to interpreted code, but instead of it being executed by the interpreter, the code is transformed into machine code by something called a compiler. The machine code is then executed by the computer (it’s CPU, GPU, memory, etc.) on which it’s run. Think of your EXEs and DLLs on a Windows computer; these are compiled machine code.

Within the context of writing source code in a text editor, you might do the following:

• Write some HTML, JavaScript, and CSS, then launch a web browser preview to check your code changes. It’s not the editor that’s running your code but a web browser engine that’s incorporated into the editor.
• Write some Python code and then launch a menu item to run it through the Python executable installed on your computer. The result of the code might be returned back to the editor as plain text. Again in this case, it’s not the editor running the code. It’s just sending it off for processing.
• Write some C++ code in the editor and then click a button to compile it and launch the result. Perhaps after compiling, an actual application runs. The editor isn’t running the code here, it’s your actual computer, running machine code that the compiler created from the C++ you wrote.

Which text editor is best for Python/HTML/C++/etc…?

This is a tough question to answer. Certainly there are crowd favorites for different languages, but the reality is that users’ needs and preferences vary so greatly that there’s not necessarily any one standard.

For example, dedicated Python developers might opt for Python-specific editors like PyDev or Jupyter. These editors include specific tools for Python development and debugging and are referred to as integrated development environments (IDEs). For those who might only intermittently need to modify a Python script, a more general purpose and lightweight editor like Sublime Text or UltraEdit is often a good choice.

For C++ development, an IDE is almost a necessity. Visual Studio is the top choice for Windows, and XCode for Mac. For Linux, Eclipse and code::blocks are popular options. Some other IDEs rising in popularity for C++ are C++ Builder, CLion, and even VS Code.

When it comes to back-end web development, i.e. JavaScript, TypeScript, PHP, and Python, many users settle for VS Code, which, while not a true IDE, features a robust extension ecosystem that provides much helpful ancillary functionality. 

For front-end web development, like HTML, JavaScript, and CSS, many editors like UltraEdit work well. Again, it really depends on what you want out of your editor. Do you want a precise “surgeon’s scalpel” that is highly tailored to a certain language, framework, or workflow? Or a general purpose text editor like UltraEdit which can cover nearly all your editing needs and also includes FTP and SSH, but works for many other text editing jobs as well?

The best way to discover which text editor is best for you is to try them out for yourself. Remember that there are many different jobs a text editor can do beyond just source code editing. Don’t forget to explore as much as you can – you’ll often be delighted by what you discover!

So…which text editor is the best?

As mentioned in the last section, this is a very difficult question for anyone to answer, even for themselves. There is too much subjectivity involved, and it would be a daunting task for anyone to fully and fairly evaluate the vast array of text editors available today.

I’m tempted to provide a comprehensive list of text editors ranked by performance and functionality. But I’m not even sure I could trust my own rankings.

Instead, I’d like to lay some basic groundwork on how you can discover this for yourself.

Determine what’s most important to you in a text editor.

Are you looking for an “opinionated” editor that assumes a lot about your workflow; for example, that you’ll always be using Git, or that you’re restricted to just a few programming languages? Are you looking for a maximally “helpful” editor that aggressively offers to auto-complete the text you’re typing, rearrange your project for you, etc.? Or are you looking for maximum control and freedom and want the editor to stay out of your way as much as possible?

Is a powerful Find/Replace important to you? What about large file and data handling? Do you need to reformat data like JSON, CSV, etc.? Do you need functionality like FTP and SSH to interact with remote servers?

These are all things to think about when evaluating your next text editor.

Read reviews from other users.

It’s no secret that product reviews contain a treasure trove of useful information when you’re in the market for a new piece of software. Oftentimes, you’ll find use cases and solutions to problems from other users that you didn’t even think about. UltraEdit, for example, has over 1100 reviews on G2 and many more on various other review platforms.

Additionally, reviews can clue you in to potential issues or incompatibilities you may have with the text editor. It might become obvious after reading a review that the editor you’re considering is designed for one specific use case or language type, for example.

One word of caution, here – you can get lost in reviews! Gauging the opinions of others is a wise move, but if you put too much weight into it, it can result in analysis paralysis which makes decision-making very difficult. Take every review with a grain of salt, and remember, humans are not objective.

Consider factors beyond just the text editor.

The functionality and user experience of an editor are very important. The most important. But don’t fall into the trap of fixating only on features and functionality without considering other important factors.

For example, is security important to you? Maybe you work on proprietary source code or in an industry where all data must be kept private and safe. Not all editors offer the same level of security or even any security at all. And in the event that a vulnerability is discovered, the response time to patch may widely vary by publisher.

If security is important to you, take a hard look at UltraEdit – we’re one of the most secured and hardened editors available. This is a major reason why we are trusted by so many financial institutions, healthcare companies, and government agencies.

What about support? It’s great if you’ve read that a text editor can do just the thing you need, but what if you’re having trouble figuring out how to do it? Or maybe the editor doesn’t function as expected when you try it? Who can you reach out to? Most free and open source text editors don’t provide any level of professional support. Your best bet is searching online, perusing StackOverflow, or asking for help on forums (and bracing for the inevitable annoyed “RTFM” responses).

Contrast this with a professionally and actively supported product like UltraEdit, which includes world-class support. Need assistance figuring out a regex to extract data from your log files? No problem – send us an email, and we’ll respond with an accurate solution for your specific problem…often within an hour or less. 

Commercial support is also a significant factor for larger company and enterprise deployments. In these organizations, customizations and controls are often needed to ensure the editor complies with corporate policies. It’s invaluable having a support rep at your disposal who can help you with your custom deployment and configuration to meet the requirements of your unique environment.

Try it for yourself.

Finally, and most importantly, you shouldn’t use any text editor that you can’t at least try for a few days before a full license is required. There’s simply no substitute for “kicking the tires” of a text editor to ensure it does what you expect, meets your needs, and just feels right.

That’s why we offer a full 30-day free trial for UltraEdit and all our other products. The proof is in the experience. No amount of marketing or sales can beat a great user experience in a text editor, and we’d love for you to see for yourself! 😉

The post What is a text editor? Help me choose one! appeared first on UltraEdit.