-
Notifications
You must be signed in to change notification settings - Fork 2
softint
There are two main types of application interfaces: visual and textual. Example elements of visual interfaces are windows, files, folders, and graphics. The visual interface is the most common modern software application interface. There are also textual interfaces. This interface is primarily a "command line", which is often more powerful and faster than the visual interface, but less intuitive. You have to memorize commands before you can really make use of it.
A visual interface are also known as a graphical user interface or "GUI". This is probably the most common contemporary interface for use with computers, especially on the end-user (client) side. This interface type uses visual, graphical representations to interact with files and applications. Some examples of visual interfaces and their graphical elements are files and folders, windows, icons, applications, and buttons.
We will also introduce web interfaces. This interface type makes use of web browsers like Internet Explorer, Safari, Firefox, and Chrome. The browser connects to a remote webserver to display information.
GUIs use visual navigation, "point-n-click", "drag-n-drop", and "gestures". These kinds of physical actions should correspond to computer behaviour. They should be fairly intuitive.
Examples of intuitive GUI behaviour include:
-
Dragging a folder icon onto another should move that folder into the other.
-
Dragging to highlight a selection area should select all of the icons visible in that selection area.
GUIs are most useful for common or visual tasks. Anything that is intuitive (like moving folders around) and also any task that requires visual aid (like photo editing or video editing) is a natural fit for a GUI.
A GUI is probably a more intuitive interface for most computer users. You can explore the interface by simply "poking around" to figure out how things work without having a lot of memorized knowledge beforehand.
On the web, a server provides an interface to a common client application such as a web browser. This is most useful for network-centric, multi-user, distributed apps. For example, a web interface will allow you to deliver a centralized application (or data source) to a lot of different people, no matter where they are located.
Web technologies include markup, styles, scripts, and frameworks. Markup (HTML) is the way you categorize, organize, and modify web content. Styles (often bundled as "themes") are the design side of a web interface. Scripts allow for more complex interaction than basic HTML — more dynamic content and personalized design. Frameworks are generalized web structures used to build modular web sites and applications. Data exchange technologies allow for communications over the web and between applications.
The most familiar form of "markup" known to most people is "HyperText Markup Language", or "HTML". This is the basic language of the web, the primary language used to format web pages and build websites. It uses "elements" and "tags" to organize content and is not visible to the end user (unless they view the "source").
Tags and elements can have default effects, like the <b> tag for bolding text. It can also be used strictly for organization purposes. For example, a header tag will denote information (such as document properties) that will be stored in a header area. You can also define custom tags and elements for the purposes of styling or scripts.
Styles use "Cascading Style Sheets", or CSS files, to specify the visual design of a web page or website, as opposed to the content. Design elements, in a well-designed website, should be defined separately from the content so that either can be modified independently. Stylesheets allow for layout, like margins and sizes of elements, different colors, fonts, backgrounds, images, and much more.
You can quickly change the look of your website without changing the content by switching stylesheets. This is the reason why it’s important to separate your design and your content. If you want to update the look for your website or change it for different users, you can quickly swap out styles without affecting (requiring changes to) any of your content.
There are two categories of scripts used in web technologies: so-called "server-side" and "client-side" scripts.
Examples of server-side scripting include CGI, PHP (probably the most common), ASP (a Microsoft technology), JSP (based on Java), and Python web frameworks.
Server-side scripts take data from the client web browser and process the information, run the application, then send a response back to the client. All of the data processing happens on the server-side of the communications link.
Client-side scripting generally uses JavaScript (different from Java) or Flash. JavaScript is probably the most common language used for client-side scripting. Instead of sending data to the server for processing, a script runs in the client (web browser) to process the data locally.
So, you may request data from the website and then process it locally before displaying it in the web browser, or you may generate data locally and process it before sending it to the server, for example, to validate input values.
Client-side scripting is also useful for offline processing or to offload processing from the server to the client to improve performance, for example, to decrease response times.
Frameworks allow users to easily add and modify content without having to know the underlying web technologies. Early frameworks were developed for web journalists and bloggers. If you want your users to not have to know about HTML, styles, and scripting, and just want to them to get content up on the web, frameworks make this really easy. Once you install a web framework on your website, you can add and remove users, pages and videos, all through a GUI interface in the browser.
Content management systems (CMS) are the main type of web framework you will see. Examples are Drupal, Wordpress, and Django. Drupal, an open-source framework, is popular on university campuses like the University of Washington. The pages will all have a standardized look, and access-rights will control what kinds of changes you can make.
Learning management systems (LMS) are content management systems geared toward educational/academic use. One example, Canvas, is used at the University of Washington. With it, faculty members can start with a pre-configured course website and then add lectures (videos, audio, and slides) and "wiki" pages without having to write code.
Hypertext Transfer Protocol, or HTTP, is the basic communications protocol of the web. A client sends a request and a server returns a response. For example, of you want to load a web page, your browser sends a request to the server and the server returns the data needed to load the web page. All you have to do is click on "hyperlinks" or enter an address into the "address bar" (also called the "location bar") to load new pages. The browser handles details of the communications protocol for you.
Extensible Markup Language (XML) is another markup format, similar to HTML, but with more generalized and flexible capabilities. XML is used as the data exchange format for Rich Site Summary (RSS), a service offering news syndication in the form of a "news feed". This allows content creators to push out new content to their users very easily and conveniently. XHTML is an XML-compliant version of HTML meant to bring HTML into the broader XML standard and to better facilitate data exchange.
Simple Object Access Protocol (SOAP) is a communications standard for sending XML formatted data between web applications. This allows a website to offer content and functionality that may come from several other websites, regardless of the programming language used to build the website or what computing platform it (or the client) may be running on.
JavaScript Object Notation (JSON) is an alternative to XML, which is simpler and easier for humans to read and write. JSON uses a hierarchical data structure of nested attribute-value pairs, separated by colons and enclosed by brackets.
One major application of JSON is Asynchronous JavaScript and XML (AJAX), which uses XML or JSON to facilitate highly interactive web applications. AJAX exchanges data between the client and server in the background to minimize disruptions to the web user and offer a smoother user experience. A web application built using AJAX will allow data to flow between the browser and the server dynamically, without requiring a form to be submitted and a new web page to be loaded.
An example would be Google Mail (GMail), where you can view and receive messages without having to reload the entire GMail page. Instead, the page updates dynamically as new mail is received. With AJAX, web applications can approach the performance and usability of desktop applications, but also benefit from combining the computing and data resources of a server with the convenience and familiarity of a web browser.
Most text-based interfaces are command-line interfaces (CLI), though some offer text menus and full-screen interfaces. Text-based interfaces contain nothing but characters, lines, and sometimes colors. Mouse capabilities are limited and vary from application to application. Therefore, almost all interaction is through the keyboard. You can do some basic graphics, simulated with text, but there are not a lot of visual elements to these interfaces.
Associated with the CLI is the application programming interface (API). These provide the building blocks to develop programs. They allow third party programs to hook into existing applications to exchange data or enhance functionality. Some APIs are used locally via function libraries installed in files on the local system, while other APIs function over a network. So, you can access data or features hosted elsewhere and use them within your own application without having to host those resources locally yourself.
Command-line interfaces (CLI) use text prompts, commands, or menus. They have flags and options to modify command execution. They take arguments that you want the command to act on, such as a file name. They are great for data manipulation because you can quickly use these commands (or create scripts containing many text commands) to manipulate data often a lot faster than you can pointing and clicking around a visual interface.
A CLI is a relatively fast interface due to a lack of graphics, so it’s good for low bandwidth, remote connections. Command-line interfaces are often used for server interaction, especially remote server interaction, because they are very quick to respond and minimize the amount of overhead sent over a network.
On operating systems offering a GUI "desktop" environment, such as Windows or OSX, text-based interfaces are often run inside of a graphical "window" to offer basic control of the application through "clipboard" features like copy and paste (using a mouse) or standard window buttons such as "close", "minimize", and "maximize". CLIs require exact commands, including spelling, case, and syntax. You have to learn and memorize the commands and their usage to be productive with CLIs. The commands offer some built-in help facilities, and there are extensive on-line reference manuals if you need more help with basic usage or advanced syntax.
You can manipulate your data a lot faster using a CLI, in many cases, assuming you are familiar with the commands and their options. This takes practice, so those who make frequent use of a CLI will see greater productivity gains from using it, compared to the occasional user. This is why a CLI is less popular on computer systems designed for less technical, less specialized, or more casual users.
As you become a "power user" of a system, you will naturally look for efficiencies, like replacing many mouse clicks with a few keystrokes. As you seek to automate routine and laborious activities, you will find that command-line tasks are easier to automate since the commands can usually be saved into a file and run as a script. These are the reasons that motivate people to invest time in learning and using CLIs, even though they might seem unfriendly or mysterious at first.
The operating system we know as Microsoft Windows evolved from it’s command-line ancestor called "Disk Operating System" (DOS). The command-line interpreter was a program called COMMAND.COM, later replaced by CMD.EXE in Windows NT and its modern descendants, including Windows XP, Vista, Windows 7, Windows 10 and the various Windows Server versions since Windows NT. PowerShell was released with Windows XP Service Pack 2 (SP2) and has been included with later versions of Windows. PowerShell is a more powerful shell that integrates better with the more modern features of Windows.
The "Bourne Again Shell", or Bash, is the standard shell or command-line interface on Unix systems such as Apple OSX and Unix-like systems like Linux. You can also install Bash onto Windows with some third-party utilities if you prefer the features or commands of Bash more than those of DOS or PowerShell. Cygwin and GitBash are popular Bash implementations for Windows.
Many scientific and statistics apps use a command-line interface. Examples are Stata, R, and MATLAB. While some of the commands used with these applications may be inspired by traditional operating system shell commands, many will be will be specific to the application and may form a unique programming language.
As with the other CLIs, users of these systems can realize productivity gains over users of GUIs as they gain experience and begin to automate tasks. Again, the main improvement over a GUI may be in much faster data manipulation.
An "Application Programming Interface" (API) is a code library useful for building modular systems, automation and back-end data transfer. APIs can be access locally through library files or remotely through a network connection.
An example of using a remote API would be using the Google Maps API to geocode location information (like postal addresses), or to build custom maps using a base map layer from Google, centered on your specified location with your preferred zoom level.
Since APIs are accessed through program code, and code is usually written as text commands, we have included this type of interface in our discussion of textual interfaces. For example, you may use a CLI that provides access to an API, run a program that calls an API function, or write software that calls API functions to perform various tasks on your behalf. All of these depend on text (program code) or a text interface (code editor or command-line interpreter). The data exchanged using APIs are often in text formats as well.
The latest version of this document is online at: https://github.com/brianhigh/research-computing/wiki Copyright © The Research Computing Team. This information is provided for educational purposes only. See LICENSE for more information. Creative Commons Attribution 4.0 International Public License.