When working on my project for senior design, part of the challenge was being able to communicate with a Canon camera, and be able to send commands to CHDK.  There’s an excellent python library that does the job, but running on the Raspberry Pi, it was really slow.  After doing some more benchmarking and testing, I determined that Python was just going to be slow on the Raspberry Pi, and it was time to move on to a different language.

I decided to pick C++ for a few reasons:

1. It’s just about as fast as you can get.  I’m sure there are people who will say that it’s not quite as fast as C, but it’s going to be pretty close.  Having a compiled language is much faster than any interpreted language.
2. It’s object-oriented.  I felt that pyptp2 had a great API, and was already accustomed to using it.  With an object-oriented language, I could simply implement this existing API.  I also feel that objects provide great assistance to the programmer.
3. I wanted to.  I’ve been wanting to get into C++ and see what the syntax is like and what it’s capable of, but haven’t had a good chance to.  This provided me this opportunity.

So, I started work on building a PTP library in C++.  I’ll note here that there IS a PTP library in C.  However, I had a lot of trouble figuring out how to use this library (it’s heavily tied in to the ptpcam program it comes with), and all CHDK extensions I could find were poorly documented, and, again, tied heavily to some other program.

Having said all that, I’m very proud with where libptp++ is.  It’s as functionally complete as I need it for my senior design project, but I’m still working on expanding it.  The CHDKCamera class it provides is mostly complete, but the PTPCamera (for camera’s that don’t or can’t run CHDK) is unimplemented.  Going forward, I’ll need to look into what functionality that class will need to provide.

I’ll also note that I did my best to document everything using Doxygen strings.  One of my complaints about libptp2 is that it’s poorly documented, so I don’t want to run into the same trap.  Run libptp++ through Doxygen and you’ll get some wonderful documentation.  There’s even an example included in there!

I’m releasing this code under the LGPLv3.  Basically, this means (to my understanding) that you can use it however you want, as long as you release the source code.  Additionally, the LGPL allows this library to be included in commercial products.  Again, though, the source code must be provided.

I hope someone else can get some use out of this library!  It’s certainly not perfect, but its current state is a good start.  I encourage anyone that finds a bug to file an issue on GitHub, or fork the project, fix the bug and send in a pull request!

https://github.com/TrueJournals/libptp–

That’s a strong statement, but it’s the truth.  Forms in Google Drive are used for so much more than simply numerical responses, with some being used for surveys, sign ups, and other data that just doesn’t fit properly in a spreadsheet.  Yet, that’s the only format Google presents this data in.  While spreadsheets are fantastic for numerical data analysis, they do little for analysis of open-ended survey responses.

And this statement even makes the assumption that you’re attempting to read the data off a computer screen.  Want to print out the data to keep a hard copy (or just to reduce eye strain from your computer’s back light)?  Forget it!  You can attempt to print the responses in landscape, but you’ll end up with an unorganized mess of papers which doesn’t really solve the original problem.

So, how can we get the data from the Form into a format that’s pleasant to read, and easy to print?  We use a script!

The Google Apps scripting engine is amazing.  I’ve previously used it to create rudimentary conditional formatting in Google Docs.  Now, I wanted to play around with it more and generate single page(-ish) reports of individual responses to a Google Drive Form.  I say “-ish”, because the script doesn’t guarantee a single page.  The end length is simply based on the response length and number of questions.

So, how do you use this script?  Just find it in the script gallery!  Searching for “Report Generator” should find the script and allow you to install it easily!  Once installed, a new menu — “Report Generation” will pop up on your spreadsheet.  Simply select the row you want to generate a report for, and choose “Generate Single Report” (or generate all at once!).  In a few moments, you’ll have a new folder in your document list, and a doc and/or PDF of the report.

The script has a few configurable options, which are for the most part self-explanatory.  I’m working on getting some documentation up at the script’s help page, but that may take me some time.  I also plan on adding more features to the script: the ability to change the folder name, change the resulting document names, change the formatting of the output, etc.  I’ve never published a script to the gallery before, but I’m hoping I’ll just be able to update the script when I have new features ready.

So, if you’re looking for a good solution to printing out responses to Google Drive Forms, check out “Report Generator” in the script gallery!

Today, I was on the phone with someone, and they inadvertently reminded me of the difference between “technical” people and “non-technical” people.

The phone call was simple: Gmail brought up a page reporting that the person’s browser was out of date because they were using Internet Explorer.  I suggested that he install Chrome, as it is a faster and more secure web browser, and now our “officially supported” browser, and proceeded to walk him through the installation.

And when I say walk him through the installation, I mean walk him through every step of the installation.  Every button he should click, when he should click them, etc.  During this process, he explained to me why he was asking for my help at every step of the process:

I’m always worried I’m going to blow something up.

So, this is the difference between “tech” people and “non-tech” people: the non-tech people think that if they click a wrong button, their computer will either explode, or stop working permanently.  The tech people have opened their computer to find that no explosives are contained within.

One of the things I enjoy doing is breaking my operating system.  I use Ubuntu Linux as my main operating system, and regularly do stupid things that might be considered destructive.  But that’s OK — I know that I can always get my data, and I enjoy going through the processes of figuring out what went wrong, and how to fix it.

In a word, I’m fearless when fixing computers: I know that if I click the wrong button, there’s always a way to go back or undo whatever I just did.  Sometimes, this is as simple as clicking a “back” or “undo” button.  Sometimes it’s a bit more involved, but that’s OK!  Because it means I’m going to learn what doesn’t work, and possibly learn something more about my operating system while I attempt to fix what’s broken.

If there’s one piece of advice I can give to non-tech people, it’s this: don’t be afraid to click buttons.  Seriously.  Most buttons you press are not going to permanently destroy your software.  If you’re worried about losing data, make a backup of whatever file you’re working, then click buttons to your hearts content!

But, as some have pointed out, Google isn’t doing so with a huge profit margin.  It’s not that Google is losing money on this deal, per-say, but it doesn’t seem that they’re making enough profit to survive on this business alone.  Luckily, this isn’t a problem for Google, as they have plenty of other revenue streams.  But, it does lead to a question of Google’s true motivation in this move.

So, I offer here my theory: Google is becoming an ISP to put pressure on existing ISPs to upgrade their infrastructure to be able to provide cheaper and faster access.  Currently, there isn’t an ISP I’m aware of that can come close to the deal Google’s making in Kansas City for residential customers.  If Kansas Citians realize this, they’ll flock to Google, leaving bigger ISPs (Comcast? AT&T?) in the dust.

Of course, as businesses, Comcast and AT&T should do whatever they can to keep their customers.  At first, they might just offer to lower prices for customers that threaten to leave, but that really can’t maintain them long-term.  They will be forced to do something to remain competitive.  Especially if Google starts to move into other areas.

Remaining competitive will mean upgrading networks. That’s just a simple fact. The current residential Internet infrastructure just can’t compete with what Google’s offering.  And as long as things remain as they are, the major players have no motivation to put money into upgrading their networks.  I believe we’re seeing essentially the same thing with cell phone providers in the US: there isn’t enough competition to force true network infrastructure upgrades.

So, here’s my predictions for the next 10-20 years:

• Major ISPs in Kansas City will slowly start to upgrade their infrastructure and offer lower prices in order to compete with Google’s offering.
• Google will start to move into/threaten to move into other areas.
• Large ISPs will (and this might be very wishful thinking) learn from the Kansas City situation and per-emptively start upgrading their infrastructure across the nation.

After all this happens, it doesn’t really matter if Google moves into other areas, or even continues to offer service.  The end result is that they’ve accomplished their goal, and that’s good for all of us.  If things proceed how I think they will, the US will see some major improvements in its residential Internet in the coming years.

The problem I ran into was this: often, there are other tasks to be completed, so I’m not just staring at the WHD ticket queue the entire time I’m at work.  However, if a client logs a ticket, I have no way of being notified without going to the web help desk page and checking manually.  This results in one of two things happening: either I check the ticket queue every few minutes, breaking my workflow on other projects, or a ticket doesn’t get responded to for a while.

I wanted a way to be notified of new or updated tickets that pop up without having to continually go back to the WHD tab of my browser to actually check for new or updated tickets.  Unfortunately, without an API, I thought this was going to be difficult.  Until I found this: a WHD Notifier for Chrome.

However, this still didn’t quite achieve what I was looking for.  While this did provide me with a notification of the number of new or updated tickets within the browser, it didn’t notify me when this number changed. So, I still had to watch my web browser, and even then, continually check this small, inconspicuous number in the top-right corner of my screen.  Since Chrome extensions are simply Javascript, HTML and CSS, I decided to try my hand at modifying it to better suit my needs.

Here’s the list of things I needed:

1. Pop-up notifications of a change in the number of new/updated tickets (like in Gmail).
2. The ability to not save username and password.  The computers share a single profile between multiple users, so I don’t want individual passwords saved past the browser session.
3. (Optional, if I could figure it out) Grabbing login info from the WHD web login, so you don’t have to go into the extension options every browser session.

After some coding, a lot of trial and error, and a lot of research, I was able to meet all three goals. If you’d find it useful, you can download WHD Notifier version 1.5.  Simply configure it with your WHD URL, choose what to display/be notified of, and you’re good to go.  If you login to web help desk, the notifier will grab that login information and start updating.

If you’re interested in seeing the source code for this extension, you can find a zip of the source here.  I’ll see if I can throw it up on GitHub later today or this weekend.  There’s some interesting things being done here — submitting the login form in WHD sends a call to forms.submit() instead of going through the normal submit procedure — this means that I couldn’t simply add an onsubmit handler to capture the login information.

Instead, I inject another piece of JavaScript into the page which overrides the submit() method for all forms.  This calls chrome.extension.sendMessage to message the background page with the username and password, then proceeds to call the submit() method I had overridden.  You can find the form handling things in autoLogin.js and autoLogin2.js.  I had to inject autoLogin2.js on the page because chrome content scripts aren’t allowed to override prototype methods.

If we ever update our WHD installation, I’ll try to update this extension again to use the new API — I should be able to add some more features with that, too.  For now, this should work for all versions of WHD 10.0.8 or later.

Update: Code is now on GitHub

Here’s what I came up with:

var w = 0;
$("label").each(function() {
    if($(this).width()>w) w=$(this).width();
    // Assume the input immediately follows the label
    var input = $(this).next();
    input.prop('id', input.prop('name'));
    $(this).prop('for', input.prop('name'));
});
$("label").width(w+10);
$("label").css('float', 'left');

And here’s what it does: first, it loops through each label on the page looking for the maximum width. When it finds that, it sets all labels to have a width of (maximum width)+10px. The extra 10px are just so the label and field aren’t directly on top of one another.

In the same loop, this code associates the label with the field next to it. For my sake, I made the assumption that I will always have <label>…</label><input />. If this is not the case, the code will associate the label with the wrong field. It simply sets the next element’s id to be the same as its name, and sets the label’s “for” property to be the element’s name, also.

Use this with caution. If you’re not careful, you could end up with duplicate IDs (a no-no). There are other reasons this code isn’t necessarily a good idea, but it’s good enough for me. For a page with a lazy HTML coder, this will work perfectly.

Bonus: Add input.prop(‘placeholder’, $(this).text()); inside the loop to also set the “placeholder” text to whatever the label is. You could also detect if the browser supports “placeholder”, and hide the label if it does:

var w = 0;
$("label").each(function() {
	if($(this).width()>w) w=$(this).width();
	// Assume the input immediately follows the label
	var input = $(this).next();
	input.prop('id', input.prop('name'));
	input.prop('placeholder', $(this).text());
        if('placeholder' in document.createElement('input')) $(this).hide();
	$(this).prop('for', input.prop('name'));
});
$("label").width(w+10);
$("label").css('float', 'left');

Conditional formatting in Excel is very, very robust.  For this project, I needed to change a row’s background color and font color based on three possibilities:

1. If Column E has any text, the row should be red.
2. If Column A and Column D contain different values (case-insensitive), the row should be yellow.
3. Otherwise, the row should be green.

Unfortunately for me, Excel’s conditional formatting works on a per-cell basis.  However, Excel does provide the ability to choose conditional formats based on a formula!  After some fiddling with Excel functions, I was able to generate formulas to check different cells in the row, then apply the conditional formatting based on that.  I ended up with these three formulas, executed in this order, and corresponding with the above three conditions:

1. =AND(CELL(“contents”, INDIRECT(CONCATENATE(“E”, ROW())))>0,ROW()>1)
2. =AND(CELL(“contents”, INDIRECT(CONCATENATE(“A”, ROW())))<>CELL(“contents”, INDIRECT(CONCATENATE(“D”, ROW()))), ROW()>1)
3. =AND(CELL(“contents”, INDIRECT(CONCATENATE(“E”, ROW())))=0, CELL(“contents”, INDIRECT(CONCATENATE(“A”, ROW())))>0)

Wow!  First, notice all of these start with an AND function.  AND evaluates the conditions given, performs a logical AND on all of them, and returns a boolean true or false based on that.  Explanation of the conditions:

1. Two conditions:
• CELL(“contents”, INDIRECT(CONCATENATE(“E”, ROW())))>0 checks for text in Column E. If there is nothing in the cell, the value is 0.
• ROW()>1 checks if this cell is NOT in the first row.  The first row is my header row, and I don’t need that one color coded.
2. Two conditions:
• CELL(“contents”, INDIRECT(CONCATENATE(“A”, ROW())))<>CELL(“contents”, INDIRECT(CONCATENATE(“D”, ROW()))) checks if the contents of the cell in Column A and the contents of the cell in Column D are different. The <> operator is “not equals”, and Excel seems to automatically do a case-insensitive comparison.
• ROW()>1 checks if this cell is NOT in the first row.
3. Two conditions:
• CELL(“contents”, INDIRECT(CONCATENATE(“E”, ROW())))=0 ensures that Column E is empty. (Again, the value is 0 if there is nothing in the cell)
• CELL(“contents”, INDIRECT(CONCATENATE(“A”, ROW())))>0 ensures that there is some value in Column A. If there’s no value in Column A, there’s no point in any highlighting.

Alright… So, with all those conditions set up, text is automatically highlighted based on what values are entered. This made editing the spreadsheet really easy: simply type in values, and the highlighting is automatic. If I go back and change something later, the highlighting changes without me needing to do anything.

Next, however, I decided that it might be useful to bring this spreadsheet into Google Docs. This would allow me to easily share the document with my supervisor, and he can share it with the relevant people that need the information.  Upon importing the spreadsheet in Google Docs, my highlighting went away.  As it turns out, Google Docs does support conditional formatting, but not via a formula.

So, I now have two options: perform the highlighting manually (tedious), or figure out a workaround.  Since I enjoy tinkering out things, and I knew about the Google Apps scripting engine, I decided to see if I could figure out a workaround.  A lot of tinkering and documentation later, I have the following script:

function getTableRange(ss, activeSheet) {
  if(activeSheet == "renaming") {
    return ss.getRange("A2:E"+ss.getLastRow());
  } else {
    return null;
  }
}

function getColorsRenaming(cell1, cell4, cell5) {
  // Abstract this function out so we can easily add different colors if we want.
  var colors = new Array(2); // bgColor = colors[0], textColor = colors[1]

  if(cell5 != "") {
    // "Notes" cell has a value -- red
    colors[0] = "#ffc7ce";
    colors[1] = "#9c0006";
  } else if(cell1 != cell4) {
    // Cell 1 and 4 contain different values -- yellow
    colors[0] = "#ffeb9c";
    colors[1] = "#9c6500";
  } else {
    // No notes and they're the same -- green!
    colors[0] = "#c6efce";
    colors[1] = "#006100";
  }

  return colors;
}

function firstRun() {
  var ss = SpreadsheetApp.getActiveSpreadsheet();
  var tableRange = getTableRange(ss);
  var bgColors = new Array(tableRange.getNumRows());
  var textColors = new Array(tableRange.getNumRows());
  for(var row = 0; row < tableRange.getNumRows(); row++) {
    bgColors[row] = new Array(tableRange.getNumColumns());
    textColors[row] = new Array(tableRange.getNumColumns());

    var bgColor = "#FFFFFF";
    var textColor = "#000000";

    var cell1 = tableRange.getCell(row+1, 1).getValue().toLowerCase();
    var cell4 = tableRange.getCell(row+1, 4).getValue().toLowerCase();
    var cell5 = tableRange.getCell(row+1, 5).getValue();

    var colors = getColorsRenaming(cell1, cell4, cell5);

    for(var col = 0; col < tableRange.getNumColumns(); col++) {
      bgColors[row][col] = colors[0];
      textColors[row][col] = colors[1];
    }
  }

  tableRange.setBackgroundColors(bgColors);
  tableRange.setFontColors(textColors);
}

function onEdit(event) {
  var ss = SpreadsheetApp.getActive();
  var editedCell = ss.getActiveCell();
  var editedRow = editedCell.getRow();

  var tableRange = getTableRange(ss, SpreadsheetApp.getActiveSheet().getName().toLowerCase());

  // editedRow-1 below because tableRange starts at row 2, but editedRow is absolute
  var cell1 = tableRange.getCell(editedRow-1, 1).getValue().toLowerCase();
  var cell4 = tableRange.getCell(editedRow-1, 4).getValue().toLowerCase();
  var cell5 = tableRange.getCell(editedRow-1, 5).getValue();

  if(SpreadsheetApp.getActiveSheet().getName().toLowerCase() == "renaming") {
    var colors = getColorsRenaming(cell1, cell4, cell5);
  } else {
    // Unfortunately, if row colors aren't uniform, this'll cause issues...
    // Hmmm... I'll come back to that if I decide something like that should happen
    var colors = [tableRange.getCell(editedRow-1, 1).getBackgroundColor(), tableRange.getCell(editedRow-1, 1).getFontColor()];
  }
  var bgColors = new Array(1);
  var textColors = new Array(1);
  bgColors[0] = new Array(tableRange.getNumColumns());
  textColors[0] = new Array(tableRange.getNumColumns());
  for(var col = 0; col < tableRange.getNumColumns(); col++) {
    bgColors[0][col] = colors[0];
    textColors[0][col] = colors[1];
  }

  var row = SpreadsheetApp.getActiveSheet().getRange(editedRow, 1, 1, tableRange.getNumColumns());
  row.setBackgroundColors(bgColors);
  row.setFontColors(textColors);

}

A couple things to note here:

1. The first run function exists solely to do the first run of highlighting.  Since I imported the document without the highlighting, I needed something to perform the initial functionality before going forward.
2. The onEdit function is run every time the spreadsheet is edited. It finds the highlighted cell, grabs the correct values from the row, figures out and sets the colors.
3. getTableRange and getColorsRemaining are simply helper functions, since this functionality is used in both firstRun and onEdit.

I know there’s not a lot more documentation about the code, but it’s pretty readable thanks to Google’s nice APIs.  However, this successfully updates the highlighting any time a row is edited. The onEdit function ONLY checks the row of the last edited cell for efficiency’s sake.  Even so, it’s not as smooth as Excel.  It takes a moment before the row is actually updated, but that’s fine for my sake.

By tweaking this script, it should be pretty simply to adapt this sort of conditional formatting via formula for any situation.  Unfortunately, Google doesn’t provide Excel’s formula entry for conditional formatting, so this is the next best thing.

“Are these computers secure? I’m going to be putting in my credit card information, so I want to make sure these computers are secure.”

How do I even begin to answer this question?  After the customer left, my coworker and I had a small laugh at this question, because the answer I eventually gave this person was a simple “yes”.

My coworker pointed out that I could have given this person any answer — as long as it had a few buzzwords, it would be believable.  ”Oh yeah, the memory addresses of the internet piplines sync well with Adobe Connect, so its definitely secure.”

My original answer was one about the security of a wired connection versus that of a wireless, pointing out that these computers have wired connection, so yes, they are secure.  This only gained a quizzical look from the uninitiated.

My next answer was going to be a note about SSL.  Perhaps a small explanation about how security is up to the place you are entering your credit card information, with a note that you should always check for “HTTPS” when entering credit card information.  However, if the wired vs. wireless explanation was confusing, this would have done nothing to clear up the situation.

So, instead of attempting to explain security, or gain further insight into what this customer was actually asking, I simply gave the answer “yes”.  It might seem like a cop-out, but it was the only answer I could give within her frame of knowledge.

I leave you with this video of Richard Feynman attempting to explain how magnets work, and instead explaining why he can’t answer “Why” questions:

So, how exactly do these sites operate?  How can anyone run a profitable business by selling $1,000 products for about $20?  The answer isn’t generous owners.  While we might like to think that there are people that generous in this world, it’s simply not a sustainable business model.  Click through to the rest of the post, and I’ll do my best to explain how these sites work, and why you shouldn’t (or maybe should) waste your time.

Where’s the Profit?

The first, and obvious, question when dealing with a site like this is where’s the profit?  How do you create a site that sells items for pennies on the dollar, and still make money?  It’s a simple trick, really, but most people will participate without even realizing what’s going on.  The trick is in what happens when a bid is placed.  When a bid is placed, a couple things happen:

1. The bidder loses some money.  For sake of argument, we’ll say $0.80.  Bids are purchased in “bid packs”.  More on this later.
2. The price of the item increases by $0.01.
3. The time to the end of the bid gets reset to anywhere from 10-20 seconds remaining.

Whoever wins the item then pays the final price of the item.  Now, let’s see this in action: let’s say there’s a 16 GB WiFi-only iPad2 up for bid (retails for $499).  The bidding starts at $0, and someone eventually decides to bid, boosting the price up to $0.01.  BUT, what also happens is that bidder loses one of their “bids”, which costs about $0.80.  Finally, the time remaining is set to 20 seconds.  After 15 seconds (there are 5 seconds remaining on the bid timer), another person bids.  The price is set at $0.02, this bidder loses a “bid”, and the remaining time is set to 20 seconds.  This process continues until the price of the item gets to… $18.47, the bid timer runs out, and the winning bidder pays $18.47 for the iPad2.  WOW! What a steal!  But, let’s look at how much money the website actually gets.

Remember that each bid costs the bidder $0.80.  If the iPad2 sold for $18.47, that means there were 1,847 bids placed.  Let’s do some math: 1847*0.80=$1,477.60!  But wait, there’s also the $18.47 paid as the final bid price.  That brings the total amount of money the site raked in for this iPad2 $1,496.07.  If the bidding site bought the iPad2 at the retail price of $499, that means the site made a profit of $997.07! That’s a $1,000 profit margin for one item.  Sites like this sell multiple items in a day.  That means huge profit margins, for little work.

What are these “Bid Packs”?

When you sign up for a site like Quibids, before you can start bidding, you’ll be forced to buy your bids, as outlined above.  When signing up for Quibids, you must buy a “starter bid pack” for $60 which gets you 100 bids (quibids charges $0.60/bid, other sites vary).  From this point, regardless of whether you win anything or not, you’ve spent $60.  You could easily spend all 100 of your bids without winning any items, which means you’re out $60 and have nothing to show for it.  If you finally do win an auction… congratulations!  How much have you spent buying bids?  Chances are, you’ve spent more than just the $60 on the initial bid pack.  Again, that’s if you win anything at all.

Unfortunately, I don’t have the $60 to spend on nothing right now, so I can’t tell what the bid pack options are after the initial buy-in.

So why isn’t it a scam?

It’s not a scam because QuiBids is very open about all of this.  Most people just don’t read all this information.  Additionally, it’s difficult to tell that you’re losing money when you’re just bidding, and, at that, only losing $0.60 each time.  By making the amount of money you lose each time you bid a trivially small amount, QuiBids is able to trick you into not realizing that you’re actually losing money and getting nothing.  This certainly sounds like a scam!  Again, though, people actually do win items off these sites, and they’re all very open about how this whole process works.

How can I beat the system?

Note: The following is complete speculation and guesswork on my part.  I take no responsibility for your actions following reading this.  This is an outside view of the process, and I could very easily be very wrong in this matter.

The trick to beating a site like QuiBids is simple, but lengthy: study.  Find an item you want, and look for similar items on the site.  Spend a month or two studying these items and figuring out how much they sell for.  With that information, you should be all site.  When the item you want is up for bidding.  Don’t bid until the item gets close to the average price you’ve found in the past month or two, and then bid to win.  If you study enough and save your bids, I figure you should be able to win an item.  Granted, you’ll spend $60 on the bid pack, then another $20-$50 for the item, so you’re still looking at around $100.  But, for an item that costs $600-$2,000, this is still a steal!  I figure a strategy like this should make you a winner.  Most people try to get in on the ground floor of these auctions, and hope they can get it cheap.  The trick would be to save your bids until the end, then bid to win.

Should I risk it?

This is a tricky question, and the answer is most likely no.  Odds are, you’re going to waste a lot of time bidding and get nothing in return.  If you have the patience to try my method outlined above, and can afford to spare $60, I would say go for it!  Best case scenario, you can get some item you’d like incredibly cheap.  Worst case, you’ve already said you have $60 to spare if things don’t work out.  For the average Joe, however, I would say it’s not worth your time.  Stick to paying full price for items you really want, or you’ll end up losing money without gaining anything.

For those of you who still haven’t heard, the bird is the word Google+ is Google’s new social networking experiment.  Their response to Facebook, if you will.  Google has more-or-less tried this before, with Buzz, but Buzz never really took off.  At this point, it’s difficult for me to tell what Google’s strategy is for how Google+ and Buzz will coexist.  Right now, they seem to be completely separate, yet strangely intertwined.  I have a feeling that as Google+ develops, it will eventually completely replace Buzz.

I hope this is helpful.  Unfortunately, I’ve left out screenshots for now.  I’ll try to get some in later this week to better illustrate what I’m talking about. Added screenshots July 4 @ 11:50 PM.

Now that you know what Google+ is, click through to read an overview of my view of the evolution of Google+, a review of the UI, and my general thoughts on things.

Evolution of Google+

While Google+ is an entirely new product at Google, it clearly combines past experiments to make for a more pleasant and combined experience.  This goes all the way back to Google Talk.  Granted, Google probably wasn’t thinking of leading up to Google+ all the way back when designing Google Talk, but Google Talk is still greatly integrated into the Google+ experience.  It has to be.  Social networking is all about communication.  My friends and I often complain about the poor quality of Facebook Chat, but I’ve never had a single issue with Google Talk.  From this standpoint, Google is starting on very solid ground.  Having a good instant messaging system is definitely a must for a new social networking website if it even remotely hopes to compete with the likes of Facebook.

However, Google was able to take this a step further than Facebook has.  Although there are rumors of Skype video chat being integrated into Facebook later this week, Google+ has video from the start thanks to Google Talk.  There are some good and bad points to this.  The good news is that Google+ handles video chat in the form of “Hangouts” which allow up to 10 participants in-browser, cross-platform.  The bad news is that this requires the installation of the Google Talk browser add-on (not just standard flash), but that’s a small price to pay.  Hopefully, this add-on won’t be required in the future with the help of WebRTC, but that won’t be for a while.

As noted above, Buzz also seems to influence Google+, but I have yet to determine quite how so far.  Right now, Google+ and Buzz do seem to operate as separate entities, but I wouldn’t be surprised if that changed by the time of official release.  When viewing a user’s profile in Google+, you have the ability to see their Buzz posts.  However, I have a feeling Buzz posts will soon be converted to Google+ “shares”, and that Buzz tab will disappear.

Another prevalent Google influence in Google+ is the “+1″ feature that has been around for a couple months.  +1 is Google’s version of the Facebook “like”.  You can +1 websites, posts, pictures, etc.  It’s a great way to quickly say “this is cool, check it out.”  Facebook users have been crying out for a “dislike” button for a while, and there is notably no “-1″ button in Google+.  Perhaps that’ll come in the future, though.

My last paragraph is much speculation on my part.  I believe Google Wave has and will have impact on Google+ also.  The only possible impact I see right now is the notification system, which now present in all Google products if you are signed in.  The bar at the top will instantly notify of relevant account activity.  I speculate that Google Wave had something to do with the code behind this notification system.  I’m also guessing that in the future, we’ll see more real-time communication and update ability in Google+ courtesy of what Google learned with Wave.

Relevant Concepts

Circles

How Google+ Circles Show Up

It’s difficult to write a Google+ post without talking about Circles, so I’ll start with that.  In Google+, circles allow you to organize your friends, and this organization is a basic idea of how social networking works in Google+.  This is something that Google has done right from the start, as opposed to Facebook, who have just recently implemented “Friend lists” that no one really seems to use and are a bit clunky.  The circles solution is elegant and beautiful: people can exist in as many different “friend circles” as you please.  The default distribution is: Friends — the people you know in real life; family — as much or as little as you want; acquaintances — people who you know, but might not want to share too many personal details with; and “following” — people you don’t know personally, but whose posts you find interesting.

But, you are not locked into this simple four-circle organization.  You can create as many circles as you want.  Perhaps, for instance, you want to separate high school friends from college friends.  Or have another circle for colleagues.  The organization is endless, but completely up to the user, and, to a point, enforced.  When adding someone as a friend, to use the Facebook terms we’re familiar with, you simply put them in a circle.  And by put them in a circle, I mean literally that: drag and drop their name into a circle.  The method is executed flawlessly, and is a great way to keep things organized.

Now, when posting content, you have a choice of who to share with.  Maybe something embarrassing happened that you’re happy to share with friends, but you’d rather not have your family know of.  Not a problem: simply only share that post with your “Friends” circle.  It couldn’t be simpler to share, but limit.

Hangouts

Hangouts are exactly what the name implies: virtual hangouts.  Creating a hangout is a way of saying “Hey, I’m bored.  Anyone want to hang out?”  This is the video chat feature of Google+, and, unfortunately, I really can’t say much of it because I haven’t had a good chance to try it out.  The feature definitely looks promising, though.  Hangouts can be limited by circle or by individuals.  From what I’ve seen, I’m not sure if Hangouts include IMing or not.  Unfortunately, the computer I’m using right now is old, slow, and lacks a webcam and microphone, so there’s little testing I can do in terms of the Hangouts feature.  It seems nice, though.

Sparks

Sparks seems to be a way to integrate Google Reader into Google+ — kind of.  Tell Google something you’re interested in, and it’ll bring up news relating to that subject.  From there, you have the option to share posts to your circles.  This seems to be a stripped-down non-customizable RSS reader.  However, it does give an interesting way to keep up on some topics from within your social networking site, and a good way to share news articles.  I haven’t found much use for it yet, though.

Profiles

What a Google+ profile looks like

Finding personal details about your friends is, of course, an important part of social networking, and it seems that Google has decided to make Profiles a big part of Google+.  Luckily, they’ve already created Google Profiles a while ago, so if you’ve filled out that, there’s not a lot of work you need to do to get Google+ set up.  Google+ also allows extended privacy controls for profile details.  Again, circles play a big part in this.

Privacy/Takeout

Take your data with you

Since many, many people have complained about privacy concerns with Facebook, Google has decided to let you control your privacy as much as you could possibly want.  Almost every aspect of Google+ can be privacy controlled by, you guessed it, circles.  This is a perfect way to do this, simply because of how elegant circles are.  There’s not much to say on this topic, because it simply works how you expect it to work — you can control who sees what.  There’s not much more you can ask for in terms of privacy control.

Along with Google+, Google introduced Google Takeout.  Takeout allows you to easily export your data from Google, in order to either back it up or take it somewhere else.  Google is very open about this: they want to provide you the flexibility to own your data.  This is something, again, that people have complained about with Facebook.  Finally, with Google+ and Google Takeout, you actually own your data — not Google.

The Interface

Google+'s left panel on the "Stream"

One word: elegant.  Google is working on a cross-service redesign of its user interface in order to make an overall more elegant, simpler experience.  Google+ is the glue that seems to tie all this together, along with the driving force behind it.  It seems that Google wants you to stop thinking about its separate services as separate services, and start thinking about them as one website.  I think that in the future, more and more services will start to integrate themselves into Google+.  The Google+ bar and redesign are just the beginning of this.

Right now, the Google+ bar (the bar at the top of Google) simply allows access to Google+ notifications from any Google service, but, again, I feel that we’ll see an overall more streamlined cross-service experience in the future.  Right now, Google+ notifications are awesome in the fact that you don’t have to leave the Google+ bar in order to see notification details.  This is another plus for Google.  Facebook notifications require you to go to whatever relevant page the notification is for in order to see what the notification is telling you.  The Google+ bar doesn’t require this.  Click the notification number, click the notification, and relevant details will slide into view in the top right corner of your screen, without having to leave the page.

At first, I wasn’t sure I liked the color choices in the new design — everything is very muted, orange and grey with some blue highlights — but it’s growing on me.  The whole interface is, in fact, very clean, and the color scheme works.  It’s Google’s way of drawing your focus away from the design, and towards the content.  It’s not the overall design of the website that’s important, it’s the content you’re sharing and that’s being shared with you.

Mobile Experience

Of course, no modern social networking site could ever become popular without some kind of mobile experience.  Currently, the Google+ mobile experience is limited to Android phones, but that will change in the future.  Luckily for me, I now have an Android phone, so I’ve been able to play with the Google+ mobile app a bit.  Let me first say this: it is way better than Facebook’s mobile app.  The app runs smoother and works better overall.  Here’s a couple key features from the mobile app.

Instant Upload

This is awesome.  The idea is that you can have your phone instantly upload any pictures you take to Google+.  Then, later, when you’re at a computer, you can choose which pictures to share, and organize your photos.  Take anywhere, deal with later is the motto here.  While cell phones are great for taking pictures on the go, computers often work better to do the heavy lifting of organization and describing.  Now, you don’t have to worry about choosing which photos to upload.  Simply upload all of them, and worry about which ones you want others to see later.

Huddles

Huddles are the mobile, text-only version of Hangouts.  This is where I’m slightly disappointed.  Hangouts and Huddles are two completely separate entities; Huddles are mobile-only, and Hangouts are computer-only.  From this standpoint, there is no cross-over between the mobile and the computer experience, which is extremely disappointing.  I hope this changes in the future, because there is no reason that some of your friends should be left out of a conversation just because of whether or not they’re sitting at a computer.  I really hope to see a bigger cross-over in this respect in the future.

The Review

The Good

Overall, I’ve come to like Google+ a lot more than Facebook.  From a cleaner way to organize friends, to a cleaner interface, to some new features that just plain work better than Facebook.  On top of that, the fact that it integrates with Gmail means that I need one less tab open when browsing.  I also like status sharing a lot better on Google+.  Facebook does let you customize sharing with friends lists, but this is a recent after-thought.  In Google+, this is built-in from the beginning.  On top of that, Google+ status seem more multi-purpose than Facebook’s in that you can location tag any status update: pictures, videos or links.

Circles are by and far the best feature of Google+.  Being able to categorize my friends is a great way to manage them, and the way Google enforces this categorization is elegant.  The notification system also works perfectly.  With a modern browser, there is no reason to leave a web page to get content from another page, and Google’s notification system does exactly that.  No matter what Google product you’re using, not only can you see notifications, you can see the content behind the notification without leaving the page.  This is something that isn’t implemented well in Facebook.  In order to view a notification, you really have to stop whatever else you’re doing in Facebook, and view the notification.  Not so in Google+, and it works beautifully.

I really like the workflow of Google+, but I will also admit that I’m still getting used to it.  Every now and then, I find something that might not work quite how I expect it to, but I haven’t encountered any unreasonable behavior.  There are a couple paradigm shifts I’m still getting used to, but, again, that’s not necessarily a bad thing.  Google+ has no wall to speak of, you simply restrict who you share a status update with.  Additionally, private messages have been done away with in favor of e-mail.  Events are non-existent due to Google Calendar.  Features that we take for granted in Facebook are hidden due to their presence in other Google products.  I predict that, over time, this integration with other Google services will become more and more transparent.  But, then, I’m stuck in the mindset that separate Google products are separate websites.  It’s obvious that Google wants me to stop thinking about them this way.

The Bad

I’ll admit: I don’t see much wrong with Google+.  On top of that, a lot of things I do see as “bad” are only “bad due to being different in comparison with Facebook”.  Although, this will be a large hurdle for Google.  It’s difficult to convince people that the way they’re doing things is wrong, and that you have a better way.  If Google is able to do this, they have a chance to take over, or at least make a dent in, the social networking market.  Until that happens, however, people won’t change their ways.

As stated above, I’m a bit disappointed in the separation in the mobile and web experiences.  I see no justification for Huddles and Hangouts being entirely separate entities, so I’d like to see these two drawn together more.  I understand that you might not want to allow video chat on mobile devices, but that simply means that you should allow text chat on browsers and integrate Huddles into Hangouts.  As it is now, Huddles are a mass text-messaging system, with “Reply All” being the only option.  This needs changed to Huddles being integrated with Hangouts so everyone can communicate regardless of location and device.

Overall

Overall, I’ve really enjoyed using Google+.  I’m really hoping that more of my friends will migrate to Google+, but I will also admit that I’ll be surprised if that happens.  There’s a possibility that the transition from Facebook to Google+ could be similar to the transition from MySpace to Facebook, but I think that would require Facebook falling behind in technology.  And, let’s face it, Facebook isn’t letting that happen.  Right now, what’s going to cause people to switch is how Facebook handles privacy, and that simply isn’t a big enough argument for most people.  At this point, I’m stuck using both networks, because most of my friends aren’t on Google+.  Unfortunately, that means I’ll keep using Facebook more than Google+, which means the switch will never happen.

Google+ does a lot better than Facebook, and provides a smoother, cleaner, more elegant social networking experience.  But, until Facebook actually falls behind, it will stay in the spotlight because people will see no reason to switch.