UltraEdit https://www.ultraedit.com/ UltraEdit Sun, 25 Feb 2024 16:14:52 +0000 en-US hourly 1 https://wordpress.org/?v=6.4.3 https://www.ultraedit.com/wp-content/uploads/2022/10/cropped-Logo-32x32.png UltraEdit https://www.ultraedit.com/ 32 32 UltraEdit Masterclass: Are you accidentally leaving your security wide open? [Webinar Recap] https://www.ultraedit.com/blog/ultraedit-masterclass-are-you-accidentally-leaving-your-security-wide-open-webinar-recap/ https://www.ultraedit.com/blog/ultraedit-masterclass-are-you-accidentally-leaving-your-security-wide-open-webinar-recap/#respond Sun, 25 Feb 2024 16:14:52 +0000 https://www.ultraedit.com/?p=29034 A security breach is a serious risk for companies that utilize user data for their system to work. Even text editors are no exception and can be the subject of malicious attacks. That said, let’s follow UltraEdit’s webinar on how to protect yourself against breaches and save yourself the headache of dealing with it in […]

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

]]>
A security breach is a serious risk for companies that utilize user data for their system to work. Even text editors are no exception and can be the subject of malicious attacks. That said, let’s follow UltraEdit’s webinar on how to protect yourself against breaches and save yourself the headache of dealing with it in the future. 

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.

]]>
https://www.ultraedit.com/blog/ultraedit-masterclass-are-you-accidentally-leaving-your-security-wide-open-webinar-recap/feed/ 0
Securing your software: How UltraEdit, a text editor, keeps your data safe https://www.ultraedit.com/blog/securing-your-software-how-ultraedit-a-text-editor-keeps-your-data-safe/ https://www.ultraedit.com/blog/securing-your-software-how-ultraedit-a-text-editor-keeps-your-data-safe/#respond Tue, 30 Jan 2024 04:17:47 +0000 https://www.ultraedit.com/?p=28654 UltraEdit (UE) employs stringent security measures to keep you and your data safe because your chain of software security is only as strong as its weakest link. Even as a native application with relatively fewer risks and vectors of attack, we will always ensure that your text and code editor have been fortified and vetted […]

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

]]>
UltraEdit (UE) employs stringent security measures to keep you and your data safe because your chain of software security is only as strong as its weakest link. Even as a native application with relatively fewer risks and vectors of attack, we will always ensure that your text and code editor have been fortified and vetted properly.

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:

ultraedit security techniques

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

BI’s Internet Crime Complaint Center 2022 Internet Crime Report

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

security webinar sign up

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

]]>
https://www.ultraedit.com/blog/securing-your-software-how-ultraedit-a-text-editor-keeps-your-data-safe/feed/ 0
What is a text editor? Help me choose one! https://www.ultraedit.com/blog/what-is-a-text-editor-help-me-choose-one/ https://www.ultraedit.com/blog/what-is-a-text-editor-help-me-choose-one/#respond Thu, 11 Jan 2024 01:04:24 +0000 https://www.ultraedit.com/?p=28304 Introduction: The History of Text Editors 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 […]

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

]]>
Introduction: The History of Text Editors

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!)

hex editor edit image file

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:

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.

compare text editors

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?

encoding text data

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. 

native text editor vs online text editor

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.

]]>
https://www.ultraedit.com/blog/what-is-a-text-editor-help-me-choose-one/feed/ 0
What is Markdown? https://www.ultraedit.com/blog/what-is-markdown/ https://www.ultraedit.com/blog/what-is-markdown/#respond Mon, 01 Jan 2024 05:46:06 +0000 https://www.ultraedit.com/?p=28714 In light of an ever-growing text editor market, we are constantly thinking of ways to make UltraEdit better. Our most recent release, which includes the oft-requested Markdown support, is one product of those efforts. So as of v25.20, UltraEdit includes full support for Markdown highlighting, editing, and previewing! Coupled with our new live preview feature in […]

The post What is Markdown? appeared first on UltraEdit.

]]>
In light of an ever-growing text editor market, we are constantly thinking of ways to make UltraEdit better. Our most recent release, which includes the oft-requested Markdown support, is one product of those efforts. So as of v25.20, UltraEdit includes full support for Markdown highlighting, editing, and previewing!

Coupled with our new live preview feature in UltraEdit v25.20, if you’re already writing Markdown documents you’ll be able to enjoy a real-time preview of your rendered Markdown as you make them in your source file. Additionally, we’ve added a completely new syntax parser for Markdown, so you’ll get full, context-aware Markdown code highlighting support out of the box. No plugins to download and install, no config files to set up. It just works—and that’s the way it should be.

Those of you who are already familiar with Markdown will understand why this is so exciting. But there are others among you who have heard of Markdown but have never used it, or who haven’t heard of it at all! So we wanted to talk about some of the reasons why Markdown is so great.

What Is It?

Markdown is a plain text formatting syntax aimed at making writing for the internet easier. The philosophy behind Markdown is that plain text documents should be readable without tags mussing everything up, but there should still be ways to add text modifiers like lists, bold, italics, etc. It is an alternative to WYSIWYG (what you see is what you get) editors, which use rich text that later gets converted to proper HTML.

It’s possible you’ve encountered Markdown without realizing it. Facebook chat, Skype, and Reddit all let you use different flavors of Markdown to format your messages.

Here’s a quick example: to make words bold using Markdown, you simply enclose them in * (asterisks). So, *bold word* would look like bold word when everything is said and done.

All told, Markdown is a great way to write for the web using plain text.

Why Use It?

It’s Easy to Learn and Fast to Use

Markdown is dead simple to learn. The official syntax can be found here, but most of what you’ll need to know is that typing **word** or __word__ will make it bold, typing *word* or _word_ will italicize the word, links are written like this [anchor text](http://www.URL.com), and lists are written exactly how you’d expect: just hit enter and add any of these three characters at the start of each line: -, *, +. So this:

– List item 1

– List item 2

– List item 3

Becomes this:

  • List item 1
  • List item 2
  • List item 3

Or you could always use a tutorial to learn how to write Markdown, like this one.

So typing Markdown is almost always faster than writing with a rich text editor, especially when you start getting into things like links or bulleted lists, which either make you use the mouse or force you to memorize a complicated sequence of keyboard shortcuts. One caveat is that if you need complicated text elements, such as tables, you’re better off sticking to HTML. Fortunately, Markdown has full HTML support, so you can code a table in HTML and go right back to Markdown in the same document.

Plus, it’s much easier to read raw Markdown than it is to read raw HTML. Which, you know, was part of the reason Markdown was even invented.

It Converts to HTML Easily

Now, if you’re going to be writing HTML, you should just…write HTML. But if you’re, say, writing an email or a readme file where you need HTML’s formatting options but not the full breadth of its features, Markdown is perfect.

Markdown converts to HTML flawlessly, sparing you the hassle of opening and closing all those tags. So. Many. Tags.

In fact, Markdown has the software to convert the plain text to HTML built in! So Markdown is actually a text-to-HTML conversion software in addition to being a markup language.

Plus, have you ever tried to convert from a .docx file to HTML? You often get so much extra formatting and spacing that it’s not worth the effort.

Markdown is Futureproof

By “futureproof,” we mean that Markdown is a plain text format. For as long as plain text is the standard (which it will be for a long, long time), Markdown will be usable and openable by modern programs. Compare this to Microsoft Word, which has 8 different filetypes as of 2018. Keeping things plain text ensures there will never be an outdated version, so software doesn’t need to update to keep up with the format.

Markdown does have its own filename extension: .md, but it was designed to be perfectly readable as a raw text file. So it’s safe to say that Markdown isn’t going anywhere.

It’s Used Everywhere

You might expect that Markdown’s use has stalled as rich text becomes more and more popular, but that’s actually incorrect. Markdown’s presence has only grown since its introduction, and it continues to do so.

Markdown is the unofficial standard on popular coding sites such as GitHub. It is also the default formatting option for popular communication tools such as Skype, Slack, and (to a lesser extent) Facebook Messenger. Wikipedia even uses a modified Markdown syntax they call wikitext.

In a world of social coding that’s only becoming more social, the programmer who doesn’t know Markdown will find themselves at a disadvantage (or, at the very least, confused for a little while).

So learn Markdown, if for no other reason than so you can keep up with the industry.

You Don’t Have to Switch Editors to Write Prose

Writing prose has always been something of a challenge using text editors. It isn’t as though it can’t be done, but plain text removes a lot of the formatting options that tend to come in handy when writing prose. This is more of a small inconvenience than a big issue, but it’s still enough that many people would rather switch to their email program to write an email or their word processor to write prose, as opposed to staying in UltraEdit and writing everything there. But with the introduction of Markdown, writing an email or blog within UltraEdit is now a perfectly viable way to proceed. Of course, you don’t have to do that, but giving people options for how to handle each situation is one of the things UltraEdit does best!

Try UltraEdit Today!

If you haven’t tried UltraEdit yet, give it a shot. Its commercial support, world-class security, and generous 30 day money back guarantee are just a few of the reasons why UltraEdit has been going strong for 25 years. With it’s new Markdown support features, there is even more to love.

Plus, you can try it completely free for 30 days!

The post What is Markdown? appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/what-is-markdown/feed/ 0
What’s New in UltraEdit 2023.2 [Webinar Recap] https://www.ultraedit.com/blog/whats-new-in-ultraedit-2023-2-webinar-recap/ https://www.ultraedit.com/blog/whats-new-in-ultraedit-2023-2-webinar-recap/#respond Fri, 22 Dec 2023 12:39:44 +0000 https://www.ultraedit.com/whats-new-in-ultraedit-2023-2-webinar-recap/ Get an overview of the latest additions to your favorite text editor in UltraEdit 2023.2—straight from the people who made them happen! This webinar will also discuss the planned changes and upcoming additions to the editor. Here is a rundown of what you can expect to get from the webinar: A rundown of the new […]

The post What’s New in UltraEdit 2023.2 [Webinar Recap] appeared first on UltraEdit.

]]>
Get an overview of the latest additions to your favorite text editor in UltraEdit 2023.2—straight from the people who made them happen! This webinar will also discuss the planned changes and upcoming additions to the editor.

Here is a rundown of what you can expect to get from the webinar:

  • A rundown of the new plugin architecture and new features utilizing it
  • Tour the new macro UI
  • See where and how to utilize the new features 

This webinar is presented by Bradley Hawkins (Product Manager) and Johnny Pickle (Chief Architect) with an introduction by Ben Schwenk (Chief-of-staff).

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

Webinar Slides

Replay

Summary with timestamps

Read the summary of the update on our what’s new page. If you want to learn more about it, you can read our in-depth announcement blog or browse through the following timestamps for a zoomed in look: 

  • 0:00:00 Introduction and webinar overview
  • 0:03:20 New Feature: Macro UI Update
  • 0:07:20 New Features: New functionality using new plugin architecture
  • 0:14:20 Plugin Examples: Code Surround + Command palette tips
  • 0:16:20 Plugin Examples: SQL Formatter
  • 0:17:09 Plugin Examples: JSON to XML
  • 0:17:43 Plugin Examples: File Splitter
  • 0:18:50 Plugin Examples: Tabs to Spaces (Leading)
  • 0:21:10 What’s next for plugins: Software development kit
  • 0:26:35 What’s next for plugins: Data/database features
  • 0:29:35 What’s next for plugins: AI Features and Support
  • 0:31:45 What’s next for plugins: New SSH/Telnet Terminal
  • 0:32:38 Question and Answer

UltraEdit has an exciting future ahead in 2024! Download the latest version of the editor now.

The post What’s New in UltraEdit 2023.2 [Webinar Recap] appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/whats-new-in-ultraedit-2023-2-webinar-recap/feed/ 0
UltraEdit 2023.2 release blog https://www.ultraedit.com/blog/ultraedit-2023-2-release-blog/ https://www.ultraedit.com/blog/ultraedit-2023-2-release-blog/#respond Fri, 15 Dec 2023 15:33:19 +0000 https://www.ultraedit.com/ultraedit-2023-2-release-blog/ The last leg of UltraEdit updates for 2023 is here! UE 2023.2 brings forth two long awaited features: First up, an overhaul of the macros interface aimed at making editing and saving macros much more intuitive and easier to use. Secondly, we have our first set of features based upon the newly developed plugin architecture, […]

The post UltraEdit 2023.2 release blog appeared first on UltraEdit.

]]>
The last leg of UltraEdit updates for 2023 is here!

UE 2023.2 brings forth two long awaited features: First up, an overhaul of the macros interface aimed at making editing and saving macros much more intuitive and easier to use. Secondly, we have our first set of features based upon the newly developed plugin architecture, mainly as a proof of concept—users will be able to submit and share their own plugins later down the line. Lastly, a couple of key bug fixes and an application icon update round up this release.

Download the latest versions of UltraEdit and UEStudio now.

Macros: Updated interface for writing and editing macros

UltraEdit supports macro recording to execute those pesky tasks of repetitive nature. With macros, you can record a set of keystrokes and presses and instruct it to repeat for a chosen number of times.

In 2023.2, the user interface and setup for macros has been redone from the ground up. The objective of this overhaul is to streamline the operation and make the execution process more intuitive. Here is a breakdown of the changes:

  • New global and individual settings
  • Gathered the main functionalities into a single location
  • Condensed most of the options from the ribbons into better-timed dialogues
  • Reduced number of windows

Sneak peek of overhauled macro UI. The dialog options have been redesigned and rearranged for ease of use.

Tech Preview: New features using new plugin architecture

This new plugin architecture was first teased in UE 2023.0 and UE 2023.1. With it in place, the editor would have more capable and performant scripting capabilities—and thus more flexibility in the features and functionality possible. 

This release highlights the first set of features based on the new architecture (intended as proof of concept of features not natively hard coded in the base editor). It may be prudent to know that even with this new technological foundation, users will still be able to access and use these features as they would normally.

Here are the new features in UE 2023:

  • Code surround

Surround code or text with the character of choice. Choose from a number of options such as quotation marks, parentheses, square brackets, curly brackets, etc.
We are adding a shortcut to do this too.

Code surround options available.

  • SQL formatter

This feature reads through a SQL command script or a dump file and makes it more human-readable. It reformats, shortens, replaces long strings, or adds indentation, spaces, and breaks. It will do whatever will make the file easier to comprehend

Reformat SQL files into a more human-readable style.

  • JSON to XML

Takes a raw JSON file and reformats it into an XML form. Some use cases include formatting JSON files for simplifying the process of adding entries to a website or a news feed-type application or web resource.

Format JSON files to XML files for easier processing in web-based applications and other similar platforms.

  • File splitter

Splits a file according to user-chosen size or number of lines. Using this feature executes a file splitting operation on an arbitrary file and splits it into chunks.
A/N: this might be the first user-submitted plugin because this is based on a script originally written by one of the users in our community, Mofi.

Users define number of lines per chunk.

  • Tabs to spaces (leading)

Converts tabs found in the start of a line or file into spaces. UE also has similar functionality for trailing tabs/spaces.

BONUS: Default shortcuts for new plugin features
You can use keyboard shortcuts to use the new features. See the list below or type “plugins” in the command palette:

New UltraEdit Icons

We’ve heard the feedback. UltraEdit is having a new set of icons based on information reported by the community. If you’re out of the loop, some users have reported that they dislike the icons we’ve introduced when we updated the website earlier this year—you can read here for the complete context.

New set of icons to be used in UE 2023.2 and onwards. From left: All Access, UltraEdit, UEStudio, UltraFinder, UltraCompare, and UltraFTP.

 

What’s Next for UltraEdit?

You’ve reached the end of UE 2023.2 updates. But we’re expecting a lot more for UE in the next year. With the new plugin architecture in place, it’s the best time to let us know what features interest you—or you might make one and share it with the community yourself with the upcoming Plugin SDK for all UltraEdit/UEStudio users that’s coming in 2024!

Watch the webinar from the developer team themselves to learn more!

Fixes and improvements

Apart from new features, this release has a lot of maintenance and improvement items. Most notable are FTP Browser using dockable window font for local/remote panes and configurable font settings for the FTP browser windows.

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.

  • Files saved without an extension erroneously have CSH extension
  • Hang when trying to access Find history
  • Alt shortcuts added to macro play dialog
  • FTP Browser now uses dockable window font for local/remote panes
  • Extension is incorrectly added when file is saved
  • Expose current tab stop value in scripting API
  • Reproducible hang when inserting comment on last line of file
  • Resolved intermittent startup instability
  • Brace matching is incorrect in PHP when strings include braces

For more information about the previous update ( UE2023.1), head over to the previous announcement blog post here. Click the download button below to download the latest version of UltraEdit.

⏰ LIMITED TIME ONLY!⏰

 

The post UltraEdit 2023.2 release blog appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/ultraedit-2023-2-release-blog/feed/ 0
UltraCompare 2023.1 release blog https://www.ultraedit.com/blog/ultracompare-2023-1-release-blog/ https://www.ultraedit.com/blog/ultracompare-2023-1-release-blog/#respond Mon, 20 Nov 2023 15:09:08 +0000 https://www.ultraedit.com/ultracompare-2023-1-release-blog/ UltraCompare 2023.1 has just been released. This update highlights the following: a QoL change used to safely merge two files into a new file, a new difference alignment method, a feature parity update from UltraEdit, and a set of new Git-focused command line options. This release is also focused on keeping features and functionality up […]

The post UltraCompare 2023.1 release blog appeared first on UltraEdit.

]]>
UltraCompare 2023.1 has just been released. This update highlights the following: a QoL change used to safely merge two files into a new file, a new difference alignment method, a feature parity update from UltraEdit, and a set of new Git-focused command line options.

This release is also focused on keeping features and functionality up to date to the latest standards. It also improves overall stability of the program based on the majority of our user reports. Browse the bug fixes and improvements section below to see the full list.

Download and try UltraCompare 2023.1 now.

Merge into New File

File compares in UltraCompare allow selective merging of differences between 2 or 3 files. However, if you’ve ever wanted to compare or merge files without altering the original two files, then this update will make it more convenient to do so. 

This new option, accessible from the folder compare context menu, allows you to create a separate individual third file so you can get a merged version without affecting the original two files.

Expanded Compare/difference alignment methods

UltraCompare now offers 2 difference alignment methods to accommodate data and line differences with efficiency and improved human readability. UltraCompare has traditionally used the Myer’s Difference Algorithm which efficiently finds the longest common subsequence. While this algorithm is fast and accurate, its comparison and alignment of differences at any given local point, meaning within a relatively short common range of lines between two files, may not match human readability expectations. Enter the Patience Diff method which does produce more human readable and expected difference matching and alignment. It accomplishes this by looking only for common elements between 2 sets of data. 

One of the most popular use cases for a diff tool is using it for analyzing source control versions.

Changes in source code are usually defined by blocks or sequences of altered code. As a dev, you see code in blocks of functions or sections, so mentally you might want your diffs to be done this way as well, as opposed to a top-to-bottom comparison of each character in the files.

UltraCompare can now be ordered to use the Myer’s algorithm or the Patience Diff algorithm for a more “context-accurate” result. This new way of aligning and showing results may be desirable for some use cases such as those mentioned above.

For contrast: The Myer’s compare algorithm goes through each character one by one, checking for differences. 

Access this new option via: Settings → Compare → Alignment method.

Integrated dockable PowerShell window

Following from recent UltraEdit updates, comes added support for an integrated PowerShell instance inside the compare UI. Instead of launching a PowerShell manually, a dockable PowerShell window can be initiated using the Layout → Terminal ribbon command.

With this new feature, you can execute command line tasks without having to navigate out of the editor. (We’ve added new command line options—more in the next section) 

New command line options

UC 2023.1 also comes with a number of new command line options—primarily based around Git commands. See the list below:

  • -bt Ignore tabs
  • -gitcp Compare to previous version
  • -gitcu Compare to unmodified
  • -gitor Open local repository

“Compare as” context menu command for Folder mode

If you are on folder mode, when you launch a comparison, you can now right click on a file and specify what type of compare to execute. You can choose from the following modes:

  • Text compare mode 
  • Binary compare mode
  • Table compare mode (Excel and CSV)

This is file specific so you can easily swap compare modes in your sessions.

What’s Next for UltraCompare?

The changes in this release apply to both Windows and Mac versions of UltraCompare (with the exception of the PowerShell update which is Win-specific). Linux will follow suit late this year or at the beginning of next year. We are hoping to have complete feature parity sometime soon.

If you have a suggestion on how to improve UltraCompare send us an email. Send us your ideas on what you want to learn more about UltraCompare or any of the products under UltraEdit’s suite of tools. Have specific questions? Let us know what tutorials, blog posts, or even webinars you want.

Bug Fixes and QoL Improvements

  • Compare engine improvements
  • CTRL+Z results in undo of ALL session edits, not just the last one
  • Add support for “Use bold font for differences” for binary/table modes as well
  • Allow users to merge “fake lines” over content in file compare to delete content in target file
  • Impossible to enter =! in quick find dialog
  • Attempting to compare specific RAR archives fail
  • Repeated crashes during specific folder merge
  • Timestamp difference enhancements suggested for comparing FAT to NTFS folders
  • When adjusting columns in one table column widths should be automatically matched in the other table
  • Improved application stability
  • Allow customer to specify folder that should be used for temp files
  • -nonrec should force non-recursive compare but doesn’t work
  • Sync rules are empty after install

The post UltraCompare 2023.1 release blog appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/ultracompare-2023-1-release-blog/feed/ 0
How one company uses UltraEdit for EDI management —an UltraEdit case study https://www.ultraedit.com/blog/how-one-company-uses-ultraedit-for-edi-management-an-ultraedit-case-study/ https://www.ultraedit.com/blog/how-one-company-uses-ultraedit-for-edi-management-an-ultraedit-case-study/#respond Thu, 12 Oct 2023 19:58:44 +0000 https://www.ultraedit.com/how-one-company-uses-ultraedit-for-edi-management-an-ultraedit-case-study/ Regardless of the industry or era, choosing a set of tools for daily work will be dictated mainly by users’ needs. New, advanced, and modern features definitely have their merits, but at the very least, a tool that covers core work often provides the biggest jump in productivity. In this case study, we look at […]

The post How one company uses UltraEdit for EDI management —an UltraEdit case study appeared first on UltraEdit.

]]>
Regardless of the industry or era, choosing a set of tools for daily work will be dictated mainly by users’ needs. New, advanced, and modern features definitely have their merits, but at the very least, a tool that covers core work often provides the biggest jump in productivity.

In this case study, we look at the story of one of our earliest users and how he made his custom wordfile to make UltraEdit, quite literally, his own unique editor.

Key Points

  • UltraEdit can be one of the best editor options for niche languages and/or mature systems that aren’t mainstream.
  • Due to its long and rich history, UltraEdit still supports thousands of programming languages usually used by enterprise companies.
  • “[Using UltraEdit] makes programming a whole lot better than trying to go through it in the natural system editor.”

Who is the subject?

Marvin Cross has worked as a senior software developer in the healthcare industry since 1983. He currently works for Hampton Roads, Va.-based Sentara Health. Sentara is one of the largest health systems in the U.S. Mid-Atlantic and Southeast, and among the top 20 largest not-for-profit integrated health systems in the country with 30,000 employees, 12 hospitals in Virginia and Northeastern North Carolina, and the Sentara Health Plans division, which serves more than 1.2 million members in Virginia and Florida.

Cross manages thousands of health insurance data interchange files and transaction records. His and his team’s work involves managing these records, verifying payments and transactions using data files, transferring records, and encoding them, as necessary.

Originally, he worked using the Pick OS with a language called UniVerse BASIC before transitioning to UltraEdit, in 2003

The Problem

Text editors, code editors, and IDEs will nominally support mainstream programming languages that are popular globally—but what do you do when a company uses a bespoke language developed four decades ago?

UniVerse BASIC is one of the lesser-known programming languages. It is a component of the MultiValue application platform, primarily used for developing enterprise apps. The base editor included in the Pick OS includes a YAFIYGI interface (a text-command-oriented document editing system as opposed to a WYSIWYG interface).

Furthermore, the files were borderline unreadable as it showed thousands of lines of source code in just two colors—black and white. There was no syntax highlighting or autocomplete—features that we have grown accustomed to today.

Cross used the base editor for years, an ordeal that he said caused “bleeding eye syndrome” because of its unintelligible format. This led to severe productivity hits as he constantly sifted through lines of unformatted and unhighlighted database files.

This is how Marvin reads, edits, and accesses the data files using the UniVerse basic base editor. There are no syntax highlighting and commands are issued via typing.

Why were they using this language/format?

Sentara has many patient records and a disproportionately higher number of data transfers and transaction records. With 12 hospitals in Virginia and northeastern Carolina, and the Sentara Health Plans division, which serves more than 1.2 million members in Virginia and Florida, you can imagine how large the database is for this system. The industry average is 80MB per patient per year—that estimates to about 96TB of text and numerical data for Sentara.

To streamline the process, the healthcare industry uses an exchange system called an electronic data interchange (EDI). This system allows one company to send business-related documents to another company in a standardized digital format.

But more importantly, these transaction records are encoded with the Pick OS using UniVerse BASIC. As with many file exchange formats, these formats nominally work well in their own ecosystem and less in others. Since the highest priority for the company is the security and accuracy of data with a functioning system, there is less incentive to risk a costly migration.

Simply put, the initial overhead requires immense effort and resources to be able to migrate to a new database system. There is simply not enough logistical and financial reason for a full reorganization—especially for a well-oiled machine that has already proven reliable. It may seem counterproductive to limit the tech you use, but most companies will often resort to maintaining whatever system they have as long as it works within reasonable margins.

Solution: Ol’ reliable UltraEdit

Sticking with what works is usually the safest option, but it is usually neither the most efficient nor the easiest way to achieve business goals. The UltraEdit editor, provided Cross the following:

  • The flexibility to both use UltraEdit as his main editor and go back to the base editor when necessary
  • Full-featured source editing for nearly any interchange format or language
  • Unhindered performance regardless of the size of the database

Another advantage that UltraEdit boasts above other editors is its longevity and long history. Tech professionals have trusted UltraEdit for nearly three decades, amassing user-requested features and becoming a time capsule for how the software development and IT space have evolved throughout the years. Accordingly, UltraEdit is one of the few text editors that still works above and beyond other sunsetted tools and software.

UltraEdit also maintains the languages and allows syntax features via its customization features or assistance from community-submitted settings and files. In fact, due to the nature of his work and the straightforward nature of UltraEdit’s code highlighting, Cross was able to easily make custom syntax files for UltraEdit. He then submitted a highlighting word file from the 1990s that is available for the community to download and use for themselves.

With the wordfile enshrined in UltraEdit’s repository, any of Cross’ teammates and colleagues can easily install UltraEdit, download the wordfile, and enjoy the benefits of a rich text and EDI editor with syntax highlighting.

Using a supplementary tool like UltraEdit is both low-commitment and low-effort, with high returns. “[Using UltraEdit],” according to Cross, “makes programming a whole lot better than trying to go through it in the natural system editor.”

Feature Highlight: UltraEdit’s Custom Wordfiles

A wordfile is a plain text configuration file that UltraEdit/UEStudio uses to highlight keywords in source code files. This is mainly used by developers who are working when their default IDE does not support a specific language or when users want to customize the syntax highlighting for a language themselves.

Besides highlighting, a wordfile can also provide the following features:

  • Code folding
  • Brace matching
  • Function listing
  • And more…

UltraEdit has a repository of user-submitted wordfiles where users can get the one they  need, or create their own just as Cross did.

The Result

The benefit of having these bread-and-butter editor features is that users get the experience of a modern development environment on virtually any code or data file. It’s hard to pinpoint how much time this small benefit saved Cross, but imagine working with a default notepad editor for any coding work—it takes exponentially longer and is extremely frustrating.

Using an unopinionated editor like UltraEdit provides developers like Cross with the basic necessities plus leeway to make the editor truly his own. There may be slight differences in EDI formats between companies and industries, but with UltraEdit’s flexibility, this no longer poses a problem. You can freely open and edit any text-based format.

Lastly, the customizable features and shareable wordfiles provided Cross and his team with multiple benefits and a significant boost in productivity.

             

The post How one company uses UltraEdit for EDI management —an UltraEdit case study appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/how-one-company-uses-ultraedit-for-edi-management-an-ultraedit-case-study/feed/ 0
Keeping your files safe: Why UltraEdit, a text editor, invests heavily in security https://www.ultraedit.com/blog/why-ultraedit-a-text-editor-needs-to-be-secure/ https://www.ultraedit.com/blog/why-ultraedit-a-text-editor-needs-to-be-secure/#respond Thu, 05 Oct 2023 19:05:34 +0000 https://www.ultraedit.com/why-ultraedit-a-text-editor-needs-to-be-secure/ When cybersecurity is discussed, a text editor is rarely the first to come to mind. It’s a simple but versatile piece of software that allows you to view, edit, and create text or code files—not much in terms of possible attack vectors. Fast forward to recent times, however, and you would find that companies cannot […]

The post Keeping your files safe: Why UltraEdit, a text editor, invests heavily in security appeared first on UltraEdit.

]]>
When cybersecurity is discussed, a text editor is rarely the first to come to mind. It’s a simple but versatile piece of software that allows you to view, edit, and create text or code files—not much in terms of possible attack vectors. Fast forward to recent times, however, and you would find that companies cannot ignore hardening their software supply chain—which includes even the humble text editor.   

In this article we discuss why a text editor like UltraEdit has placed an emphasis on security, and why it is even doubling its efforts to do so.

How is a software considered secure?

First of all, it is necessary to define what constitutes a secure software. A dictionary defines secure as “the state of being free from danger or threat.” In software, there is hardly a time when users or programs are not exposed to vulnerabilities—whether it comes from malicious actors or unintentional errors made by users themselves. 

In that case, it may be prudent to consider that having security-hardened software does not mean that security attacks and dangers disappear; instead it describes the innate ability of a software application to resist and prevent the unnecessary damages from the inevitable dangers of cybercrimes.

In the case of UltraEdit, our working definition is as follows:

A software program can be considered security-hardened when it undergoes a comprehensive set of practices and measures to protect it against potential threats and vulnerabilities, during and after development.

The cybercrime scene and cybersecurity industry

Security is one aspect that is often  overlooked when choosing text editors. The possible surface area of attack for a program run locally on a machine is arguably lesser than say, a cloud-based network system.  This holds true for UltraEdit as much as it does for other developer tools. 

However, trends in the software industry indicate an increasing reliance on software interdependence. New software is built upon both previous and current technology creating a web of software dependencies. The popularity of open source software and components have greatly accelerated the speed of development, reduced the outright costs, but has exponentially increased the potential surface area for attack as well.

This has prompted companies, businesses, and even the US government a campaign to move to zero trust models in order to curb potential open source threats and minimize the resources needed to alleviate damages from data breaches. To put this in perspective, the global average data breach cost was $4.35 million in 2022.

The Cybercrime Magazine reports that in 2004, “the global cybersecurity market was worth $3.5 billion” but in 2018, you can see that spending has dwarfed that almost eighteen times over at $66 billion. 

Investments in cybersecurity, while on the rise, is a tricky subject for businesses. Most of a company’s budget for IT and software development is allocated for tools and training. It’s straightforward: investing more usually results in increased productivity; on the other hand, investing in cybersecurity can be harder to justify—it’s an apparent financial sinkhole with no apparent benefits until something does go wrong. 

Read on further to learn more about threats and vulnerabilities in cybersecurity. Hopefully, if you are a business owner or a developer yourself, you will realize that the damages from a security breach will far outweigh the expenses of investing in even the most fundamental security fortifications.

Threats and vulnerabilities in text editors

Cybercrime takes on many forms: social engineering, network hacks, fraud, espionage, and a lot more. Each product or software in a business’ software supply chain should theoretically be as fortified as possible. It would not make sense to invest thousands of dollars on cloud security only for your system to be breached because you did not have multi-factor authentication for its employees in place.

Take for example a text editor that at its core serves a basic need of editing plain text data—it should be fairly simple to secure it and the data it edits, right? Yes, but be that as it may, the needs of users change and demands for more complex functionality dictate that the technology (and cybersecurity measures) has to evolve as well, thus the term software development. Text editors do more than just edit text nowadays (Lines blur between text, code editors, and IDEs). Auxiliary components such as HTML live previews, scripting and macros, and even hex editing may very well be considered essential.

This demand for extensibility has given birth to editor and IDE plugins—pieces of software created by the open source community that users can download from a plugin marketplace. Editor plugins and extensions provide exceptional flexibility and customizability to tailor fit any user’s specific use case. (This is so much so that UltraEdit is planning on creating its own ecosystem of plugins—more on this later).

However, plugins and extensions also greatly increase the breadth and scope of code that needs to be vetted for security, vulnerabilities, and potential development flaws. When using plugins, users waive some semblance of access to their source code in one way or another. To counter threats, plugin ecosystems and marketplaces establish guidelines and prerequisites before you are able to publish a plugin. Some ecosystems are more lax than others, while some require stringent processes before you are even allowed access to their software development kit (SDK) packages. (Examples: Visual Studio IDE Extensions guidelines and Google’s Chrome Web Store Extensions requirements)

Why security is important for UltraEdit

Software security is an interconnected chain of defenses and failsafes.

As a commercially supported software, we believe that UltraEdit should bring confidence and peace of mind to all those who use it. In the text editor space dominated primarily by open source programs, UE has the unique advantage of having a dedicated team of developers advance, manage, and fortify all of its features right from the start, minimizing zero day vulnerabilities.  

UE is a tool used by a variety of users, for many different purposes that even the creators of the tool may be unaware of. Some of these use cases may be simple everyday tasks, while others will be working with highly sensitive information or business-critical assets.

Furthermore, with ever increasing reliance on information technology, so should the standards for software. Take for example the industry shift and interruption brought about by the pandemic. Remote setups are generally more convenient but they are a security nightmare. Every employee with remote access can be an exploitable crack in your company’s security chain. Employee training and preparation is necessary but a foolproof system and software design is impeccable.  

This emphasizes the importance of security, not just for a text editor, but for software in general. However, UltraEdit is committed to making sure that it will not be a cause for concern for any of its users and customers. As a result, it has become one of the best open-source alternatives that is on par in terms of versatility, but still provides the benefits of dedicated customer support and security associated with commercial software.

UltraEdit’s Security Tools and Features

Software programs and developers employ a number of tools and techniques to harden their cybersecurity. UltraEdit employs the following three-tiered approach to harden its software security:

  • Manual and Peer Review
    Every source code commit or edit for any of the UE tools undergoes intensive review by the developer themselves before it is passed to senior developers for scrutiny. This check filters out the most apparent and probable issues.

    A company or developer without this step will have credibility issues.
  • Static Application Security Testing (SAST) tools
    UltraEdit uses a dedicated source code analysis tool to scan source code for possible vulnerabilities. These help detect issues that are laborious to check manually. This involves  filtering out common software errors such as obsolete programming techniques, memory leaks, buffer overflows, race conditions, and the like.Most companies will have SAST tools as it also provides a predictive summary of how efficient, maintainable, reliable, and portable the examined source code is.
  • Software Composition Analysis (SCA) tools
    Next up, UE looks at its external dependencies. UE is not an open source software but it does use open source components. This is one of the more crucial steps that not every company will have. 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.

A source code analysis tool will detect issues and provide general instructions on how to fix the potential issue.

 

Summary

Summing up our discussion, a text editor like UltraEdit places an emphasis on security because (1) it is necessary in this day and age where every user and company is reliant on technology and (2) because our users deserve the best and most secure system possible.

The goal posts for software security continuously move forward and no single version of any software will be 100% secure. That is why it is of the utmost importance to have a robust and stringent development process for UltraEdit. This article discussed UE’s general approach to security, and there are many threats and security issues that may arise in the future, but rest assured that the UE team will provide more than complete coverage with the best available security technology.

             

 

The post Keeping your files safe: Why UltraEdit, a text editor, invests heavily in security appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/why-ultraedit-a-text-editor-needs-to-be-secure/feed/ 0
Power Up with PowerShell: Exploring the new integrated terminal in UltraEdit 2023.0 [Webinar Recap] https://www.ultraedit.com/blog/power-up-with-powershell-exploring-the-new-integrated-terminal-in-ultraedit-2023-0-webinar/ https://www.ultraedit.com/blog/power-up-with-powershell-exploring-the-new-integrated-terminal-in-ultraedit-2023-0-webinar/#respond Thu, 14 Sep 2023 16:21:36 +0000 https://www.ultraedit.com/power-up-with-powershell-exploring-the-new-integrated-terminal-in-ultraedit-2023-0-webinar/ Discover the power of a PowerShell instance integrated within all UltraEdit applications. This presentation is aimed at making our users realize how convenient it is to do all your command line tasks from within the same workspace—no more tabbing needed! We will be focusing on PowerShell scripts as an example. Specifically, we are creating scripts, […]

The post Power Up with PowerShell: Exploring the new integrated terminal in UltraEdit 2023.0 [Webinar Recap] appeared first on UltraEdit.

]]>
Discover the power of a PowerShell instance integrated within all UltraEdit applications. This presentation is aimed at making our users realize how convenient it is to do all your command line tasks from within the same workspace—no more tabbing needed!

We will be focusing on PowerShell scripts as an example. Specifically, we are creating scripts, editing them, and running them using the integrated PowerShell window right in the editor.

Here is a rundown of what you can expect to get from the webinar:

  • An introduction to the power of command-line tools
  • See script execution inside the same editor workspace
  • Learn how to access and setup the integrated PowerShell terminal
  • A sneak peek to the PowerShell integrations and developments planned for the UE suite

Webinar Schedule

Date: Thursday, September 21, 2023
Time: 10 AM Central Time (5 PM Central European Time)
Duration: 1 hour (~30 mins presentation, 30 mins Q&A)

Presented by:
• Bradley Hawkins, Product Manager, UltraEdit
• Ben Schwenk, Chief of Staff, Idera DevTools & UltraEdit
• Johnny Pickle, Chief Architect, UltraEdit

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

 

Webinar Slides

Replay

 

 

The post Power Up with PowerShell: Exploring the new integrated terminal in UltraEdit 2023.0 [Webinar Recap] appeared first on UltraEdit.

]]>
https://www.ultraedit.com/blog/power-up-with-powershell-exploring-the-new-integrated-terminal-in-ultraedit-2023-0-webinar/feed/ 0