Mineral definition and classification

---

To be classified as a "true" mineral, a substance must be a solid and have a crystal structure. It must also be an inorganic, naturally-occurring, homogeneous substance with a defined chemical composition. The chemical composition may vary between end members of a mineral system. For example the plagioclase feldspars comprise a continuous series from sodium-rich albite (NaAlSi₃O₈) to calcium-rich anorthite (CaAl₂Si₂O₈) with four recognized intermediate compositions between. Mineral-like substances that don't strictly meet the definition are sometimes classified as mineraloids. Other natural-occurring substances are Nonminerals. Industrial minerals is a market term and refers to commercially valuable mined materials (see also Minerals and Rocks section below).

A crystal structure is the orderly geometric spatial arrangement of atoms in the internal structure of a mineral. There are 14 basic crystal lattice arrangements of atoms in three dimensions, and these are referred to as the 14 "Bravais lattices". Each of these lattices can be classified into one of the six crystal systems, and all crystal structures currently recognized fit in one Bravais lattice and one crystal system. This crystal structure is based on regular internal atomic or ionic arrangement that is often expressed in the geometric form that the crystal takes. Even when the mineral grains are too small to see or are irregularly shaped, the underlying crystal structure is always periodic, and can be determined by X-ray diffraction.

Chemistry and crystal structure together define a mineral. In fact, two or more minerals may have the same chemical composition, but differ in crystal structure (these are known as polymorphs). For example, pyrite and marcasite are both iron sulfide, but their arrangement of atoms differs. Similarly, some minerals have different chemical compositions, but the same crystal structure: for example, halite (made from sodium and chlorine), galena (made from lead and sulfur) and periclase (made from magnesium and oxygen) all share the same cubic crystal structure.

More on [ Mineral ]

Think Vitamin

Full Day Web Design Workshops: Which Would You Pick?
Cat Clark Thu, 02 Feb 2012 16:51:00 -0000
At Carsonified Towers, we’re all getting super excited for May, when The Future of Web Design hits London for another three days of learning and inspiration. As ever, we kick off the show with four full-day workshops – each lead by a totally inspirational industry leader. From 9am am to 5pm, we’ll be rolling up our sleeves and knuckling down for a serious hit of web savvy. Numbers are capped at 40 for each workshop, ensuring a great learning environment. This year’s chosen workshop topics are already proving popular. First up, we’ve got the unstoppable force of web awesomeness that is Paul Boag. Director of Headscape, Paul will be leading a crash course in Running A Successful Web Design Business: ”We like to think that being a successful independent web designer is about creating great websites. Its not. Running your own business is about a lot more than having the right professional skills. ” After wowing the crowds as a Rising Star back in 2011, Steve Fisher has rapidly become one of our most popular speakers. He’ll be joining us again in London to lead his Rock Solid UX Deliverables workshop: “No longer something that has to always be hugely complex and costly, we’ll cover the back-to-basics approach to UX design in this workshop and how to practically dispatch a rock solid responsive web design UX deliverables package.”  Next up, creator of the uber popular Coach to 5K app, Josh Clark will be crossing the Atlantic to deliver his Teaching Touch workshop – a sell out success at FOWD NYC last year: “The workshop presents nitty-gritty ‘rule of thumb’ design techniques that together form a framework for crafting finger-friendly interface metaphors, affordances, and gestures for a new generation of mobile apps that inform and delight.” Last but not least, longtime Carsonified favourites, the Web Standardistas will be joining the fun, to teach their Good Ideas Grow On Paper workshop: “Armed with some fundamental design principles and an abundance of tools – which naturally includes the Standardistas’ ‘Bag of Awesome™’ (containing a veritable cornucopia of material) – we show the aspiring analogue designer a range of methods for breaking out of the stranglehold of the often clichéd digital world.” Which workshop appeals the most to you? For detailed information on all of them, head on over to our schedule page… Thanks to Nationaal Archief  for the photo used above.
SQL Fiddle
Amit Bijlani Thu, 02 Feb 2012 15:05:25 -0000
If you like jsFiddle, then you will love SQL Fiddle. It allows you to select a database, build a schema, populate the schema and run queries against it. The service currently supports MS SQL, MySQL, Oracle, and PostgreSQL. Why is this interesting? You can compare databases, post questions to forums along with your schema and query or just prototype an idea.
Free Video: Control Flow
Jason Seifer Thu, 02 Feb 2012 14:00:24 -0000
In this 4 minute video, you will learn about the concept of control flow in Ruby. This goes in to using if/else statements and case statements This video is from Treehouse, a high-quality video training site with hundreds of short videos on topics like … Accessibility CSS3 Aesthetic Foundations Django HTML CSS HTML5 iOS Development JavaScript jQuery NoSQL PHP Responsive Web Design Ruby Ruby on Rails UX Version Control WordPress Theme Design New videos are added regularly, so it’s a great way to stay up-to-date on all the latest technology and methods. Browse the entire library of videos.
Git For Designers (Part 1)
Jason Seifer Wed, 01 Feb 2012 20:33:36 -0000
Hi designers! I’m not a designer. Sorry. I’m a developer. I can barely tell when things look good or not. This week I learned that there are different ampersands out there (thanks, Allison!). But that’s not why I’m writing today. We all have to work together. Professionally, one way we do that is by using version control. A version control system tracks changes to your code. There are a lot of different version control systems out there. Today we’ll be talking about git. Specifically, as it relates to designers making web sites. Why Use Version Control? You might be wondering why you should use version control, even for a site you’ll never collaborate with anyone on. This is a valid question. I can best illustrate the answer with a scenario you may have encountered in the past. Let’s say you’re in the middle of making a site and want to try something crazy with the css. Maybe you want to do a bit of an experiment and make everything strange shades of yellow and red. You don’t know if you’re going to keep the work when you finish it. Since it’s an experiment, it would probably be a good idea to not mess up your working version of the site. At this point, you might be thinking of creating a copy of the site and making your changes on the copy. Maybe you’re sure that you’re going to use this work and you’re going to crank through. Maybe it doesn’t work out, though. Wouldn’t it be nice if you could take a snapshot of your site now, do your experiment, and not have to worry about whether you mess things up? That’s exactly what version control is for! Step 1: Install and Configure Git In order to start working with git, though, we need to install it. Git is fairly easy to install. If you’re using Windows, GitHub has an excellent set up guide to get git installed on Windows. They also have great guides for Mac OS X and linux. If you don’t already have git installed, follow those guides and come on back here. Once you have git installed, you have to tell it who you are. This is done using the config command. Open Terminal and type in the following: $ git config --global user.name "Jason Seifer" $ git config --global user.email "jason@teamtreehouse.com" Step 2: Initialize a repository We’re going to initialize a git repository now. A repository is just a directory with one or more files we want to track the changes of, in this case our web site. Open up terminal (or command prompt on Windows) and change to the directory containing the site you want to put in to git. Once you’re in there, type the following: [~/Sites/think_vitamin] $ git init Assuming you have correctly installed git, you should see the following: Initialized empty Git repository in /Users/jason/Sites/think_vitamin/.git/ This is git telling you that thinks are working and that the path it gave you is now a repository. If you don’t see that output, go back to step 1 and verify that everything was correctly installed. Step 3: Add Your Files Now that we have initialized our git repository, we have to tell git what files we want to add to the repository. In order to do this, we use the add command. The add command takes either a single file or a path. The add command takes the changes you’ve made and adds them to something in git called the staging area. The staging area is kind of like a waiting room for git. It lets you tell git what changes you’re going to add to the main index. Since we are already in the directory with our web site, we’ll tell it to add the path of the current directory: [~/Sites/think_vitamin] $ git add . At this point, you won’t see any output. My example is just an index.html file. In order to see what git is about to stage, you can use the status command: [~/Sites/think_vitamin master]$ git status   # On branch master # # Initial commit # # Changes to be committed: # (use "git rm --cached <file>..." to unstage) # # new file: index.html # The first line of the output says "On branch master". In git, a branch is just a pointer to something called a commit (explained in the next section). Since this is our first commit, git lets us know that on the second line of output where it says Initial commit. Next, git says there are changes to be committed. My index.html file is there since it’s the only thing I have in the directory right now. This is good! Step 4: Commit Your Chages A commit in git is a pointer to a series of changes that you have told git you want to track with the add command. When you commit your changes, git writes them to the index. This is git’s way of saying "this is what the repository looked like at this point in time." So let’s commit our changes: [~/Sites/think_vitamin]$ git commit -m "Initial commit" [master (root-commit) 542d5fa] Initial commit 1 files changed, 1 insertions(+), 0 deletions(-) create mode 100644 index.html Here we use the commit command to tell git to commit our changes to the repository. The -m argument told git that we want to give the commit a message. My message here was "Initial commit" because this was the first commit to the repository. As you make changes, you can be much more descriptive. This is helpful when working on larger teams. Time Pope has a great article on writing good commit messages if you’d like any pointers. The important thing about commits is that, once you have committed changes, you can always go back to how your repository was at the point in time of that commit. How cool is that? That means that you’re now free to make horrible changes to your site. Wnat to see how Comic Sans looks for all the headers? Go for it! You can always go back. Step 4: Make some changes Now that things are committed, you can feel free to make some changes to your code. In my example web page, I made changes to the header of the page. Now we can run git status again to see what happened: [~/Sites/think_vitamin]$ git status # On branch master # Changes not staged for commit: # (use "git add <file>..." to update what will be committed) # (use "git checkout -- <file>..." to discard changes in working directory) # # modified: index.html # no changes added to commit (use "git add" and/or "git commit -a") Now we’ll add the file we just changed: [~/Sites/think_vitamin]$ git add index.html 1.9.3 [~/Sites/think_vitamin]$ git status # On branch master # Changes to be committed: # (use "git reset HEAD <file>..." to unstage) # # modified: index.html # Finally, we’ll commit the change: [~/Sites/think_vitamin]$ git commit -m "Modify home page header" [master bc8251b] Modify home page header 1 files changed, 1 insertions(+), 1 deletions(-) Great! We just made our first two commits. Our co-workers will love us for writing a descriptive message along with the second commit, too, although they might also still be mad for taking the last cup of coffee. Step 5: Make a branch Remember earlier when we were talking about making experimental changes that you may want to keep? That’ what branches are for! Branches let you easily separate your work. You can have two branches going at the same time with different work. Branches are great for experimentation with something that you’re not sure you’re going to keep. Let’s say we wanted to change the font on all headers to Comic Sans. You’re not sure how this is going to look (bad) but your client really wants you to give it a try anyway. Let’s create a branch to do that just in case we want to switch back. In git terms, we call this process creating a branch. We do that by checking out the branch and passing a flag to git saying that we want to create it: [~/Sites/think_vitamin]$ git checkout -b comic_sans Switched to a new branch 'comic_sans' Now that we’re on our comic_sans branch, we are free to make changes and commit them. This won’t affect anything on our master branch until later. Let’s make our changes: [~/Sites/think_vitamin]$ git status # On branch comic_sans # Changes not staged for commit: # (use "git add <file>..." to update what will be committed) # (use "git checkout -- <file>..." to discard changes in working directory) # # modified: index.html # no changes added to commit (use "git add" and/or "git commit -a") Git also let’s us see what changed in between what we’re about to stage with the diff command: [~/Sites/think_vitamin]$ git diff diff --git Subscribe to Vitamins_and_Minerals RSS feed