Chapter 18

Definitions

42: The meaning of life

Application: A computer program designed to perform a particular task. Applications may have a graphical interface with windows and buttons, or they may run from a command line. In this book, the Java program being packaged by Snug is generally referred to as the application.

Application Store: An online service used to publish, distribute, and sometimes sell applications. Examples include the Microsoft Store and Apple App Store. Snug does not require an application store; the executable it creates can be distributed directly to users.

Argument: Information supplied to a program when it starts. With the standard builder defaults, arguments passed to the finished Snug executable are forwarded to the Java application. Builder --jvm-arg values instead configure the JVM itself.

The Snug builder accepts arguments either from the command line or from an options file such as snug.options.

Artefact: A file produced as the result of a build or packaging process. In this book, a Snug artefact normally means the Windows executable created by Snug from your Java application.

Binary: A general term for a compiled program that a computer can run. Unlike source code, which is written for people to read and edit, a binary has been converted into a form intended for the computer to execute. snug.exe is the Snug binary used in this book.

Build: The process of turning source files or other application components into something that can be run or distributed. With Snug, building generally refers to creating a Windows executable from one or more Java JAR files.

Builder: The part of a software tool responsible for creating the finished application or package. The Snug builder is snug.exe, which takes your Java JAR files and configuration and produces a Windows executable.

CLI (Command-Line Interface): A way of interacting with a program by typing commands rather than clicking buttons and menus. Snug is primarily a command-line utility.

Code Signing: A process that digitally signs an application so that an operating system can verify who published it and whether the file has been changed since it was signed. Commercial code-signing certificates can involve additional cost and administration.

Command: An instruction typed into a terminal, Command Prompt, or PowerShell window that tells the computer to run a program or perform an action.

Command Line: A text-based way of interacting with a computer by typing commands. For example, Snug can be run by typing snug.exe followed by its options and the JAR file that should be packaged.

Command-Line Option: An additional instruction supplied when starting a command-line program. Options usually change how the program behaves. In Snug, options are used to set things such as the application name, company name, and other packaging settings.

Command Prompt: A command-line program supplied with Microsoft Windows. It allows commands and applications to be run by typing their names rather than opening them through the graphical desktop.

Compiled: Converted from programming code into a form that can be run by a computer or another software runtime. A compiled Java application is commonly distributed as one or more JAR files.

Configuration: A collection of settings that control how a program behaves. Snug configuration determines how an application is packaged, branded, and launched.

Console: A text-based area where a program can display messages and where commands may be entered. When Snug is run from a command line, its progress and results are displayed as console output.

Deployment: The process of getting an application from the person who created it onto the computers of the people who will use it. Snug is intended to make deployment easier by turning a Java application into a familiar Windows executable.

Desktop Application: An application that runs directly on a user's computer rather than primarily through a web browser. Snug is designed to package Java applications so that they behave more like conventional Windows desktop applications.

Directory: A location on a computer used to organise files and other directories. It is commonly called a folder in graphical programs such as Windows File Explorer.

Distribution: The process of giving an application to the people who need to use it. Distribution might involve copying a file, placing it on a shared drive, making it available for download, or using another process already used by a business.

Double-Click: Pressing the primary mouse button twice in quick succession. In Windows this is the familiar way of opening files and starting applications. One of Snug's goals is to allow a Java application to be started simply by double-clicking its executable.

.exe: The file extension commonly used for executable applications on Microsoft Windows. A file such as my-app.exe can normally be started by double-clicking it or running it from a command line.

Executable: A file containing a program that the operating system can run. Snug packages a Java application into a Windows executable so that the user can launch it like a conventional Windows application.

Fat JAR: A Java JAR file that contains the application's own code together with most or all of the libraries it depends upon. This makes the application easier to distribute because its required Java libraries are collected into a single JAR file. Sometimes called an uber JAR or, depending on the build tool being used, a shadow JAR.

File Extension: The letters appearing after the final dot in a filename that commonly indicate what type of file it is. For example, .jar identifies a Java archive and .exe identifies a Windows executable.

Git: A version-control system that records changes to files in a project, making it possible to review or return to earlier versions.

GitHub: A platform built around Git for hosting source code, tracking issues, and collaborating on software projects. Snug’s source repository is hosted on GitHub; consult its Releases page for any published downloads.

Graphical User Interface (GUI): The visual part of an application that people interact with using windows, buttons, menus, icons, and other on-screen controls. This is different from a command-line application, which is primarily controlled by typing commands.

For JavaFX applications, the graphical interface is provided by the JavaFX library.

Icon: A small image used to visually represent an application, file, or action. Snug can place your application's own icon into the Windows executable it creates.

Installer: A program that places an application and its supporting files onto a computer, and may also create shortcuts, Start menu entries, and uninstall information. Snug creates an executable and manages its Java launch requirements, but it is not intended to be a complete installer framework.

Internationalisation: Designing software so that its text and other user-facing elements can be adapted to different languages and regions. Snug allows its launcher messages to be customised for different languages.

Java: A programming language and software platform used to create applications that can run on many different operating systems. Snug is specifically designed to package Java applications for easier use on Windows.

Java Application: An application written for the Java platform. Java applications are commonly distributed as JAR files and require a suitable Java runtime in order to run.

JavaFX: A framework used to create graphical desktop applications with Java. The demonstration application used in this book is a JavaFX application.

JAR: Short for Java Archive. A .jar file is a package that can contain compiled Java program code, resources, and other files used by a Java application. Snug packages one or more JAR files into the Windows executable it creates.

Java Runtime: The software required on a computer to run Java applications. The user does not normally interact with the runtime directly. If a compatible Java runtime is not available, Snug can offer to download and prepare one, depending on the application's runtime-download setting.

JRE (Java Runtime Environment): A name for the software needed to run Java applications. In this book, the more general term Java runtime is used because Snug may use an installed or Snug-managed Java runtime.

Launcher: A small program whose job is to start another application and prepare anything that application needs first. The Snug launcher is built into the executable produced by Snug. It checks the Java requirements, prepares the application, and then starts it.

Local Application: An application that runs on the user's own computer rather than being hosted on a remote web server. Snug is particularly suited to local applications such as internal business tools.

Metadata: Information stored about a file or application rather than the application's main content. Application metadata can include details such as its name, company, version, and description. Snug can add this information to the executable it creates.

Modal Dialog Box: A window that requires a response before the user can continue with the current task. Snug uses dialogs when it needs the user to act, for example, to install a required Java runtime or respond to a launch error.

Native Executable: An executable designed to be recognised and launched directly by a particular operating system. Snug creates a native Windows .exe launcher around a Java application, giving users a familiar Windows application to start.

Operating System: The software that manages a computer's hardware and provides the environment in which applications run. The Windows x64 release described in this book creates applications for that platform; the Java runtime and any native libraries must also be compatible with it.

Option: A setting supplied to a program that changes how it behaves. Snug options control things such as application naming, branding, Java requirements, and launch behaviour.

Package / Packaging: The process of collecting an application and the information it needs into a form that is easier to distribute and run. Snug embeds the Java JAR files and the settings needed by its launcher into a Windows executable. It does not include the snug.options text file itself.

Parameter: A value supplied to an option or program. In this book, an option is a named setting such as --name, and its parameter is the value that follows it, such as "My Application". Argument is the broader term for information passed to a program.

Payload: The application data carried inside another file or package. In a Snug executable, the Java application's JAR files and related information form part of the data carried by the executable.

PowerShell: A command-line and scripting environment included with modern versions of Microsoft Windows. Snug commands can be run from PowerShell as well as from the traditional Windows Command Prompt.

Preview: A way of seeing how something will look before producing the finished version. The optional snug_preview.exe utility allows Snug's dialog boxes to be viewed while they are being customised.

Publishing Platform: A service that hosts software and provides a way for users to discover or download it. Snug does not publish or host applications itself; it creates the executable and leaves you in control of how that file is distributed.

Repository: A project and its history as managed by Git. A repository normally contains the files that make up the project together with a record of how those files have changed over time.

Release: A particular version of software made available for use. A release tag identifies source code; a downloadable release may also include compiled executables and other assets.

Runtime: Software that provides the environment another program needs while it is running. Java applications require a Java runtime. Snug can locate or download an appropriate runtime before starting the packaged application.

Runtime Components: The files that make up the runtime environment needed by an application. Snug can download and reuse Java runtime components rather than requiring every packaged application to contain its own complete copy.

Shadow JAR: A JAR file produced using the Gradle Shadow plugin, commonly combining an application's code and its libraries into a single file. It is a type of fat JAR. See also: Fat JAR.

Shared Drive: A storage location that can be accessed by multiple people, usually through a business or home network. An internally distributed Snug application could, for example, be placed on a shared drive for colleagues to copy or run.

Source Code: The human-readable instructions written by a programmer to create software. Source code is normally compiled or otherwise processed before the finished application is distributed to users.

Splash Screen: An image or small window displayed while an application is starting. It commonly shows an application's name, logo, or branding. Snug allows a customised splash screen to be displayed while the Java application is being launched.

Startup Behaviour: The actions a program performs when it is first launched. In Snug this can include checking for a suitable Java runtime, displaying messages or a splash screen, and then starting the Java application.

Synapticloop: The software project and publisher behind Snug.

Terminal: An application that hosts a text-based command session. Command Prompt and PowerShell are command environments that can run in a terminal.

Uninstallation: The process of removing an installed application and its associated files, shortcuts, and configuration from a computer. Snug is not a complete installer or uninstaller system.

URL (Uniform Resource Locator): The address used to identify a resource on a network or the internet, such as a web page or downloadable file. For example, the Snug documentation and releases are accessed using URLs.

Version: A number or other identifier used to distinguish one release of an application from another. Versions make it possible to tell whether one copy of a program is newer or older than another.

Web Application: An application that is primarily accessed through a web browser and usually runs partly or entirely on a remote server. Snug is aimed at applications that run locally on a user's computer rather than applications that need to be hosted as web applications.

Windows: Microsoft's desktop operating system. The version of Snug described in this book packages Java applications as Windows executables (.exe files).

Windows Executable: An executable file designed to run on Microsoft Windows, normally identified by the .exe file extension. Producing a familiar double-clickable Windows executable from a Java application is one of Snug's main purposes.