Gconf Critical Thinking

No matter what walk of life you come from, what industry you’re interested in pursuing or how much experience you’ve already garnered, we’ve all seen firsthand the importance of critical thinking skills. In fact, lacking such skills can truly make or break a person’s career, as the consequences of one’s inability to process and analyze information effectively can be massive.

“The ability to think critically is more important now than it has ever been,” urges Kris Potrafka, founder and CEO of Music Firsthand. “Everything is at risk if we don’t all learn to think more critically.” If people cannot think critically, he explains, they not only lessen their prospects of climbing the ladder in their respective industries, but they also become easily susceptible to things like fraud and manipulation.

With that in mind, you’re likely wondering what you can do to make sure you’re not one of those people. Developing your critical thinking skills is something that takes concentrated work. It can be best to begin by exploring the definition of critical thinking and the skills it includes—once you do, you can then venture toward the crucial question at hand: How can I improve?

This is no easy task, which is why we aimed to help break down the basic elements of critical thinking and offer suggestions on how you can refine the skills that drive your own critical thinking abilities.

What is critical thinking?

Even if you want to be a better critical thinker, it’s hard to improve upon something you can’t define. Critical thinking is the analysis of an issue or situation and the facts, data or evidence related to it. Ideally, critical thinking is to be done objectively—meaning without influence from personal feelings, opinions or biases—and it focuses solely on factual information.

Critical thinking is a skill that allows you to make logical and informed decisions to the best of your ability. For example, a child who has not yet developed such skills might believe the Tooth Fairy left money under their pillow based on stories their parents told them. A critical thinker, however, can quickly conclude that the existence of such a thing is probably unlikely—even if there are a few bucks under their pillow.

6 Crucial critical thinking skills (and how you can improve them)

While there’s no universal standard for what skills are included in the critical thinking process, we’ve boiled it down to the following six.

1. Identification

The first step in the critical thinking process is to identify the situation or problem as well as the factors that may influence it. Once you have a clear picture of the situation and the people, groups or factors that may be influenced, you can then begin to dive deeper into an issue and its potential solutions.

How to improve: When facing any new situation, question or scenario, stop to take a mental inventory of the state of affairs and ask the following questions:

  • Who is doing what?
  • What seems to be the reason for this happening?
  • What are the end results, and how could they change? 

2. Research

When comparing arguments about an issue, independent research ability is key. Arguments are meant to be persuasive—that means the facts and figures presented in their favor might be lacking in context or come from questionable sources. The best way to combat this is independent verification; find the source of the information and evaluate.

How to improve: It can be helpful to develop an eye for unsourced claims. Does the person posing the argument offer where they got this information from? If you ask or try to find it yourself and there’s no clear answer, that should be considered a red flag. It’s also important to know that not all sources are equally valid—take the time to learn the difference between popular and scholarly articles.

3. Identifying biases

This skill can be exceedingly difficult, as even the smartest among us can fail to recognize biases. Strong critical thinkers do their best to evaluate information objectively. Think of yourself as a judge in that you want to evaluate the claims of both sides of an argument, but you’ll also need to keep in mind the biases each side may possess.

It is equally important—and arguably more difficult—to learn how to set aside your own personal biases that may cloud your judgement. “Have the courage to debate and argue with your own thoughts and assumptions,” Potrafka encourages. “This is essential for learning to see things from different viewpoints.”

How to improve: “Challenge yourself to identify the evidence that forms your beliefs, and assess whether or not your sources are credible,” offers Ruth Wilson, director of development at Brightmont Academy.

First and foremost, you must be aware that bias exists. When evaluating information or an argument, ask yourself the following:

  • Who does this benefit?
  • Does the source of this information appear to have an agenda?
  • Is the source overlooking, ignoring or leaving out information that doesn’t support its beliefs or claims?
  • Is this source using unnecessary language to sway an audience’s perception of a fact?

4. Inference

The ability to infer and draw conclusions based on the information presented to you is another important skill for mastering critical thinking. Information doesn’t always come with a summary that spells out what it means. You’ll often need to assess the information given and draw conclusions based upon raw data.

The ability to infer allows you to extrapolate and discover potential outcomes when assessing a scenario. It is also important to note that not all inferences will be correct. For example, if you read that someone weighs 260 pounds, you might infer they are overweight or unhealthy. Other data points like height and body composition, however, may alter that conclusion.

How to improve: An inference is an educated guess, and your ability to infer correctly can be polished by making a conscious effort to gather as much information as possible before jumping to conclusions. When faced with a new scenario or situation to evaluate, first try skimming for clues—things like headlines, images and prominently featured statistics—and then make a point to ask yourself what you think is going on.

5. Determining relevance

One of the most challenging parts of any critical thinking scenario is figuring out what information is the most important for your consideration. In many scenarios, you’ll be presented with information that may seem important, but it may pan out to be only a minor data point to consider.

How to improve: The best way to get better at determining relevance is by establishing a clear direction in what you’re trying to figure out. Are you tasked with finding a solution? Should you be identifying a trend? If you figure out your end goal, you can use this to inform your judgement of what is relevant.

Even with a clear objective, however, it can still be difficult to determine what information is truly relevant. One strategy for combating this is to make a physical list of data points ranked in order of relevance. When you parse it out this way, you’ll likely end up with a list that includes a couple of obviously relevant pieces of information at the top of your list, in addition to some points at the bottom that you can likely disregard. From there, you can narrow your focus on the less clear-cut topics that reside in the middle of your list for further evaluation.

6. Curiosity

It’s incredibly easy to sit back and take everything presented to you at face value, but that can also be also a recipe for disaster when faced with a scenario that requires critical thinking. It’s true that we’re all naturally curious—just ask any parent who has faced an onslaught of “Why?” questions from their child. As we get older, it can be easier to get in the habit of keeping that impulse to ask questions at bay. But that’s not a winning approach for critical thinking.

How to improve: While it might seem like a curious mind is just something you’re born with, you can still train yourself to foster that curiosity productively. All it takes is a conscious effort to ask open-ended questions about the things you see in your everyday life, and you can then invest the time to follow up on these questions.

“Being able to ask open-ended questions is an important skill to develop—and bonus points for being able to probe,” Potrafka says.

Put your critical thinking skills to work

Critical thinking skills are vital for anyone looking to have a successful college career and a fruitful professional life upon graduation. Your ability to objectively analyze and evaluate complex subjects and situations will always be useful. Unlock your potential by practicing and refining the six critical thinking skills above. 

Most professionals credit their time in college as having been crucial in the development of their critical thinking abilities. If you’re looking to improve your skills in a way that can impact your life and career moving forward, higher education is a fantastic venue through which to achieve that. For some of the surefire signs you’re ready to take the next step in your education, visit our article, “6 Signs You’re Ready to Be a College Student.”

EDITOR’S NOTE: This article was originally published in December 2012. It has since been updated.

RELATED ARTICLES:

Sketchy Specification for a Future Configuration System

This specification is intended to cover the existing functionality of gconf plus the delta described in these notes.

Big Picture Concepts

The core concept of the configuration system is a global, hierarchical tree of key-value pairs, similar to a filesystem. "Global" means that each tree is shared across multiple processes. However, there are multiple trees and trees can be combined to get a "search path" effect where values are looked for in multiple places.

By default, there are two systemwide trees and a tree for each user. The systemwide trees are a set of default settings and a tree of mandatory settings. System daemons not associated with a user session will look up values in these two trees. A program in a user session will look up values first in the mandatory tree, then in the user's tree, then in the default tree.

Local sites may add additional trees of values, for example one associated with a workgroup or geographical region of the company.

Again, the system daemon looks at the default and mandatory trees, and the user daemon uses these same trees with a per-user tree inserted. This is important because it means that if nobody is logged in, the value used will be the default setting that a new user would get.

Application Developer API

The first step in adding configuration to an application is to create schemas for the application's settings. Schemas are XML files describing configuration keys. Each schemas file may describe multiple keys, and the information for each key should include:

  • The type of the key's value in D-BUS type signature format.
  • A relative-to-some-root name for the key. All keys in a schemas file should assume the same root. For example a schemas file may describe the keys that make up a "panel applet", and the schema can be instantiated under distinct roots for each applet.
  • Localized short and long descriptions of the setting.
  • A default value for the setting.

In addition to the per-key information, the schemas file should somehow indicate which roots are expected to be used. For example, it might say that "any subdirectory of /org/gnome/panel/applets/ gets these schemas" or for the global panel settings "these schemas apply to the root /org/gnome/panel" - the exact syntax here doesn't matter, I think only the two cases of "any subroot of /foo..." and "exactly the root /foo" are interesting. Arbitrary globbing could be allowed but I don't know the use case. The purpose of this feature is to support a gconf-editor type thing.

Unlike gconf, in this new configuration system the schemas are not stored in the configuration tree itself; schemas are instead a property of the application. Applications install their XML files to a global schemas directory, and installed schemas can be referenced by a URI identifier. In other words there's a sort of catalog mapping unique URIs to schemas files. gconf-editor would want to list all the URIs and look up the schemas for each; individual applications probably use only a few of the schemas files. The URIs here would use a domain owned by the schemas file author, as with XML DTDs.

The schemas directory should really be multiple directories following the basedir specification.

The API for apps should involve creating a settings object, with some schemas URI, at some root in the configuration hierarchy. The app should also specify whether the per-user settings should be included.

class Settings { enum { SCOPE_SYSTEM, SCOPE_USER } Scope; Settings (Scope scope, String schemas_uri_identifier, String root_directory); Variant Get (String relative_key); void Set (String relative_key, Variant value); }

The settings object should also have a way to subscribe to change notifications below the given root_directory. There probably is not a use case for subscribing to changes in more detail than that.

The change notification should include the relative name of the changed key, its new value, whether the key is currently set (or just derived from the schemas), and whether the key is currently writable. This should be done by passing an object to the change notification that includes all of this information (so the change notification callback just has one "entry" object as argument). This lets us add more fields to an "entry" in the future.

The Settings object should automatically force conformance to the schemas:

  • Keys not found in the schemas should be hidden.
  • Keys set to a different type than found in the schemas should be treated as unset.
  • Unset keys should behave as if set to the default found in the schema.

It's an essential optimization for apps to avoid loading the localized short and long descriptions, as these are huge and used only by gconf-editor style tools. An mmap() cache of schemas used by apps is one approach. I think putting descriptions in separate files manually is a bad idea since it will lead to developers not keeping them updated.

gconf-editor/regedit sort of tools would not use the same API as applications. They would have a "no schemas" or "raw" mode of loading configuration settings, an API for listing and loading schemas, and a way to edit config trees or parts of trees other than the current user's tree. API for all this should probably be kept clearly separate from the normal application API.

Implementation

The implementation should be a daemon that implements interfaces provided via D-BUS. The daemon should be able to run either systemwide or in a user session and should thus be written in paranoid/untrusting style.

The only really hard question about the D-BUS interface is how to do notifications such that apps only hear about the changes that matter to them. Otherwise each setting change wakes up all apps. The two approaches are to map each key in the configuration hierarchy to a D-BUS object path so D-BUS signals can be filtered by source object; or to have apps tell the conf daemon which signals to emit, and adjust dbus to support multicast (vs. broadcast) signals.

It's critical that the conf daemon have no state. If the daemon goes down, apps should re-establish their state with the daemon, rather than the daemon restoring its own state.

The daemon should store data in a nice XML format, it need not be the same as the current one. Can't be in fact due to using dbus types.

The daemon should have an extensible configuration file. This would allow among other things dynamically constructing a configuration tree based on the context (e.g. hostname) of the particular user session.

Transition/back-compat with respect to GConf

One option is that the new daemon has an alternate backend that reads settings from the current gconf database, especially ~/.gconf. If this database is present, then settings from it would be read in. The pain in this case is writing this backend and mapping old gconf settings to the new system.

The second option is a framework allowing apps to provide a one-time upgrade/migration script. The framework would deal with running this once for each app, when appropriate, and have features to make it easy to write the script (e.g. quickly say "old key foo goes to new key bar")

Stuff to Punt

Some notable things that don't need to be in 1.0.

  • Transactions. Nice in theory, but we've been fine without them in gconf, and supporting complex types already helps a lot.
  • Most of the GConf API can die. We don't need a GConfValue, the split between Engine/Client is pointless, GConfSchema goes away except in the gconf-editor oriented "load all schemas" type of API, GConfChangeSet goes away since we're not doing transactions.
  • "Direct" (no daemon) access can go away, its use case is covered by the systemwide daemon or worst case by a private API used only by the official command line tool coming with the config system. Maybe eventually we also want this for some "one-time" apps that don't persist and thus don't need notifications, but since dbus is starting pretty early in boot it's unclear this is genuinely useful. Just use some simple existing config files for early boot stuff.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *