This post assumes minimal understanding
of computer software. Today, we'll focus on a widely used, but
rarely understood, subset of System Software. If you'd like to learn
more about System and Application Software or Operating Systems
before moving forward, try reading my earlier post: Difference Between Application Software and System Software. By the time you've
finished reading this post, I hope you have a clear image of the
subject matter. After all,
“Where there is no
vision, there is no hope” -- George Washington Carver
Among my friends, colleagues,
classmates, and random Internet-acquaintances; I receive many
questions regarding the difference between Window Managers, Window
Systems, Desktop Shells, and Desktop Environments. Making this
distinction seems especially difficult for those previously
assimilated with Microsoft Windows. That isn't to say Windows users
are unintelligent; it's merely a testament to Microsoft's lack of
transparency. Unfortunately, this limited exposure leaves many new
and potential GNULinux users confused, agitated, and ultimately
intimidated by their first experience. Fear not fellow warriors!
Whether you're a tech-ninja or a not-so-tech-savvy, this post
explores the role each concept plays in delivering a Graphical User
Interface (GUI).
Let's begin with the definition of a
GUI. Assuming you read my previous post, you know that interfaces
are mechanisms that allow the exchange of resources between two
entities. In computing, Graphical User Interfaces are a subclass of
interfaces that enable users to graphically visualize and control
software activity. When someone talks about an application's GUI,
they refer to its look, feel, and interactive capabilities.
Likewise, an Operating System's GUI defines the overall graphical
experience of the system platform. OS GUIs establish a graphical
framework that applications work within to enhance user experience.
Not too surprisingly, this post's four concepts of focus are actually
the building blocks of an OS GUI.
If you're reading this post hoping to
learn 'the Windows way', the information will be
relevant, but not comprehensive. In Unix-like OSs (those modeled
after the Unix OS; e.g. GNULinux, Mac OS, Solaris, and BSD), there's
a clear distinction between the Window Manager, Window System,
Desktop Shell, and Desktop Environment. The Windows family of
Operating Systems, however, has a less specific definition for each
component. I suspect these blurred definitions originate from the
design principles used during development. Microsoft's goal was to
design a self-contained OS that supplies Application Software with
all the essential goodies required for a satisfying user experience.
Contrastingly, Unix-like paradigms encourage the use of stable,
modular design principles. This means that system components can,
with relative ease, be replaced by other components that serve
similar functions. Let's start investigating the roles of each OS
GUI module, shall we?
Each GUI module works as part of a
hierarchy to form what some call the 'complete desktop experience'.
However, this term refers to feature-rich Operating Environments and
not to minimal GUI requirements. In fact, a GUI can exist by having
only one of the four modules: the Window System. Since it is the
lowest layer of the hierarchy, let's begin with it. Window Systems
are the most basic interface for graphical output and user input. In
other words, the Window System is responsible for drawing graphics to
the screen and for handling keyboard and mouse activity. Practically
all Unix-like OSs use the X Window System (also called X Server, X11,
or X.org) by default. The Window System is mostly inflexible and
therefore is rarely used by itself. For example, X Server is very
limited in the way graphical applications utilize its resources. By
itself, X can only launch applications during initialization and, if
a user wishes to launch new graphical applications, they must
shutdown and reinitialize the Window Manager. Another limitation of
running the Window System as a stand-alone GUI is that application
windows are confined to static locations, sizes, appearances, and
stacking indices (whether windows are on top of each other).
Next, we have the Window Manager:
System Software responsible for handling application window state
information. By state information, I mean data regarding a window's
location, size, decorations, context menus, stacking index, etc. To
clarify, Window Systems handle screen output and user input while
Window Managers handle the logistics of application windows. When
the two work together, users are able to change window aspects
without a great deal of manual effort. Window Managers aren't
necessary, but the advantages they afford are certainly a beautiful
thing!
At this point, we have a GUI that
launches a pre-defined set of applications when the Window System
initializes. Also, thanks to our Window Manger, application windows
now have several convenient and decorative features. Our GUI is,
however, still very inflexible compared to modern expectations. For
example, if you hadn't included a word processor in the Window
System's set of startup applications, you will need to shutdown your
GUI, reconfigure it within a text-only environment, and reinitialize
it. Arguably the most desired feature we're lacking is the ability
to launch applications by clicking desktop icons. To obtain these
and other elastic capabilities, we'll move on to the concept of a
Desktop Shell.
In computing, a shell is the place
where users call home. Desktop Shells are a type of shell in which
users are presented with a familiar graphical representation of their
user profile: the 'desktop'. A Desktop Shell defines things like:
task menus and panels, desktop icons and appearances, and desktop
backgrounds. The key distinguishing features of a Desktop Shell are
the convenient utilities and widgets not included by the Window
Manager. Widget is a generic term used in computing to describe any
sort of graphical element (e.g. buttons, menus, icons, etc). Desktop
Shells are sometimes distributed as a monolithic software package,
but are typically a collection of smaller applications. Desktop
Shells can include several utilities, but the most common are:
Terminal Emulators, File Managers, and Application Launchers. Let's
take a quick detour and describe each of these.
I've avoided the topic till now (as
some users find it intimidating), but a GUI isn't the only method for
accessing system resources; there also exists a CLI (Command Line
Interface). If you're already familiar CLIs, then kudos! If not,
don't be ashamed. Long before computer graphics were 'necessary',
users achieved computational goals by typing commands into a
text-only prompt. Many OSs default to a CLI and, 'behind the
scenes', initialize a GUI for the user. When the GUI initializes,
the CLI becomes hidden and inaccessible (this isn't completely true,
but we'll avoid the details). As we learned before, the Window
System has no built-in features for launching additional applications
and, now that our CLI is hidden, we are unable to launch applications
via textual commands. To overcome these limitations, early
developers created a Terminal Emulator to give users CLI access
inside a GUI window. From this terminal, a user can run any command
that he/she could have in a pure CLI. Assuming the user launches a
GUI application via the Terminal Emulator, that application is
inherited by the Window Manager. Thanks to some clever engineers,
some semblance of flexibility can exist in our GUI.
In the X Window System, when the last
pre-defined application is closed, the entire GUI shuts down. In
'the old days', it was common to set a Terminal Emulator as the last
application, but doing this still forces us to use a CLI. File
Managers were designed as a graphical alternative to the Terminal
Emulator, allowing users to browse their digital File System. File
Systems are mechanism used for the logical ordering of data on a
block device (e.g. a hard drive). File Managers, sometimes called
File Browsers, appear as window(s) containing icons for each
file/directory within the current directory. By itself, however, the
File Manager can only browse. In order to use icons to launch
applications, we need a little help from the next Desktop Shell
application.
As implied above, Application Launchers
are used to give certain widgets a 'click to launch' capability.
What this means, is that applications may invoke the Application
Launcher if a user 'clicks' certain widgets. The primary function of
an Application Launcher is to find and launch an application's
executable file. A launcher has no visual form of its own, but it
does, however, act on behalf of many different desktop and
application widgets. Application Launchers are also responsible for
associating different file types with specific applications. This
feature is especially desired as it gives us the ability to open
applications by double-clicking our data file instead of the
application icons!
Now that we have a Desktop Shell, we
should have a very flexible and customizable workspace. Given that
we've selected a decent Window Manager and Desktop Shell, it's likely
that our desktop looks pretty sweet. At this point, we should have
things like panels and task bars, desktop icons, adorable animated
widgets, a flashy background, decorated context menus, and sleek
window designs. So what's missing from our Desktop Shell that is
present in most PC Desktop Environments? Let's check it out!
If you recall, the transition from a
Window Manager to a Desktop Shell added a few (or possibly lot) of
familiar desktop components. When a user first sits down at their
terminal, they see an inviting user interface and (assuming we've
installed useful Application Software), he/she can begin using the
system regularly. But what happens when the user encounters some
undesirable system configuration? For instance, the user becomes
unhappy with the system's excess power consumption. A solution to
this would be the inclusion of a Power Management utility. Audio
volume is another perfect example where a configuration utility would
benefit many users (no user wants to blow out their eardrum while
searching for 'adorable kittens' on YouTube). When you combine
useful configuration utilities with a Desktop Shell, a Desktop
Environment begins to emerge. However, adding utilities to the shell
is only part of creating a 'complete desktop experience'. Desktop
Environments also include a set of System Software whose goal is to
add convenience, but remains invisible to the user. Such software is
typically known as a daemon and acts as a service running in the
background. Examples of daemon software include: flash drive
detection, automatic updates, scheduling services, desktop sharing,
etc.
And now you know! Well, sort of.
Confusion is likely to creep up whenever ambitious developers blur
definitions. It's not necessarily a 'bad thing' when certain
features overlap, but it can complicate modularity and user
understanding. For Windows, this overlap isn't a problem because the
OS's self-contained nature leaves plenty of room for 'line blurring'.
It could be argued, however, that Windows' strict enforcement of the
GUI discourages users that want to switch from GNULinux or Mac OS.
I'd love to go even further with this
topic by comparing examples of each GUI module, but I'm afraid if I
keep going, I might just write a book! However, if you'd like me to
expand on any of the topics I mentioned above, or topics from any
other posts, throw some feedback my way and I'll see what I can do.
Keep learning and try not to core dump! Till next time, sayonara!
Casino Finder (Google Play) Reviews & Demos - Go
ReplyDeleteCheck Casino Finder (Google Play). A look at some gri-go.com of the best gambling sites 바카라 사이트 in the world. They offer https://septcasino.com/review/merit-casino/ a full kadangpintar game https://deccasino.com/review/merit-casino/ library,
Despite its obvious inspiration, the anime is nothing like the cartoon and will get a lot of the characters wrong, shoehorning in the traditional magical lady tropes instead. While this outraged many followers, it's pretty hilarious how goofy and ridiculous the series turned out to be. Even though Powerpuff AV쏘걸 Girls Z is inaccurate and bad, it's nonetheless a enjoyable watch for to} followers and non-fans of the unique.
ReplyDeleteThis measure made it into the 2019 NDAA which passed and was signed by the president. The clinicians at Provident who handle calls from drawback gamblers said one of many greatest hurdles for callers is shame. They say callers wrestle to understand that gambling is a valid dependancy 토토사이트 similar to other substance-abuse problems. People struggling with varied mental-health points can call the 24-hour hotline for free counseling over the telephone. The hotline is funded partially via money provided by the state’s gaming commission.
ReplyDelete