That includes:

• Desktop computers
• Tablets
• Smartphones and smartpods (iPod Touch, specifically)

I never know where the urge to write will strike me, so I need immediate access to all of my writings, and the ability to continue writing on whatever device or screen I am currently looking at.

In my experience I have found this to be not as easy as it sounds.

I have tried the following approaches:

1. Google Docs
2. iOS Notepad

Google Docs

This is arguably the most popular approach, as Google has made their Docs interface work on almost every possible operating system. They even allow editing your docs from any device, which is a tremendously easy way to keep your documents in-sync across multiple computers/devices.

I have used this approach for years, and in fact Google Docs is still where I compose all of my blog posts before they get published to this site.

The drawbacks (and the reason I am looking for a better solution) is Google Docs a less than ideal experience on iOS. You can edit your documents directly through Safari, but it becomes difficult to type and it feels very unpolished. I often get frustrated with the little intricate bugs here and there, and give up and switch to Notepad on iOS.

iOS Notepad

What makes Notepad better than Google Docs on iOS is that Notepad is a native application, and it feels more responsive and less buggy. I find I can type much easier in Notepad, and still scroll around, copy/paste text, etc - without anything crashing or acting weird.

Notepad also offers a nice feature: the notes you write can be immediately backed-up to your Gmail account and appear under the "Notes" label in Gmail. But the main drawback is you can't edit those "emails" through any interface other than Notepad on iOS. They appear only as some sort of draft in a read-only state.

The core problem

The core problem seems to be that most desktop browser or native apps don't port well to smartphone apps, and vice-versa. The companies are usually more focused on one or two platforms, as opposed to every possible operating system out there.

So although the experience is nice on one or two platforms, the rest of the time you need access to your data (through other operating systems), it doesn't exist or it's a less-polished experience.

Other solutions/ideas

Since the above two approaches have their drawbacks, I'd like to try another approach but I am not sure if these ideas will be any better:

• Dropbox
• GitHub
• Simplenote

Dropbox

I thought of maybe creating a simple text file in Dropbox, then editing it from any device, but at the moment I can't seem to edit documents via Dropbox on iOS, only view them.

GitHub

Since I already have Git set up on just about every computer I use, I could push and pull a text document every time I sat down to write. Trouble is with iOS - there are SSH apps I can use but I am not sure how the experience of typing a long article via Nano (or some other command-line text editor) would be.

Simplenote

Simplenote seems like the exact concept I am looking for, except for one thing - who are these guys, and can I trust all of my public and private notes to reside on their servers?

I almost feel like I want a more homegrown solution with easier access to my data, and a sense of security/privacy.

I find RSS unread counts to be utterly pointless. The problem is I don't think of RSS feeds and their individual items as something that I need to be alerted to (by showing me how many I have yet to read/open).

For some, it's an unnecessary source of stress. Telling people they have 216 unread items only makes them feel like they are not being productive enough, and can't keep up with it. Like they are somehow missing something important.

So for me, I try to consider RSS feeds like any other news or social network stream. That is, whatever I happen to catch when I devote time to it, then that's what I catch. Everything else can just disappear into the void of "old news." I really don't need a giant backlog of RSS feed items to catch up on, just like I don't need to read yesterday's newspaper, just because I wasn't able to (yesterday).

So if RSS readers just showed me "all items" without any indication if I opened/read it (usually it's bold and a white background, if unread), that would be preferred.

Whereas it makes perfect sense to use Github for projects that have multiple developers contributing to the code, you may wonder what benefit it has for personal projects with only a single developer (you).

It dawned on me that despite the fact that I am the only developer for my personal projects, using Github is still a tremendous time saver, and it provides a sense of clarity that the old approach could not.

The old approach for me was developing directly on my external server by connecting via FTP and saving changes directly on the server over the old version of the file.

This has numerous drawbacks:

1. Changes are saved over the old version of the file, which can be disastrous if you save a file by mistake. You better hope you have the file open in a text editor where you can "undo" the changes. Otherwise it's gone.
2. Similar to #1, there is no history of changes made to a particular file - there is just one version - the latest. If you want to see/restore old versions of the file, you had better be used to making routine backups of your files, which can be a laborious process if you manage dozens of sites/applications.
3. Modifying files from an external server can cause constant lags when saving, as every time you save it has to re-upload the file to the server. It may only be a few seconds, give or take, but multiply that by the hundreds of saves you'll likely perform during any given timeframe of dedicated work, and your lost productivity will start to add up.
4. You need an internet/network connection just to develop.
5. Your site folders must be copied to every server you want to mirror/clone your application. Changes made to any instance are not synced to other instances, causing a mixture of files that have different changes made. Which version is correct?

These are just a few of the drawbacks of developing directly on the server. (If these are not enough to re-consider your development approach, you have some serious organizational issues, and clearly do not care how you spend your time.)

Github, on the other hand, solves all of these problems, and even includes other time-saving features as well.

With Github I can keep my true master copies in a single repository, and simply clone a copy to each server I am developing on. I never have to establish a single server as having the central copies of my files. Instead, each server of mine becomes a client of Github.

Being new to Github, this was the first concept I had to wrap my head around. Once it made perfect sense, my life became so much easier.

Most importantly, you gain a sense of clarity by being able to officially "commit" file changes which provides you with the sense that your work is being tracked and backed-up properly.

So, even as the lone developer for a project, you should consider using collaborative source control.

I have been a loyal Capital One credit card user (always pay my bill on time) for at least a decade now, and yet I receive constant email and postal mail spam from them.

I've written connections to various social network services to either pull or push data, and I agree that it's like re-creating the wheel for each network. Worse yet, if you use an external library that encapsulates all functionality, you have to learn the syntax for that as well, and then you never truly know what's going on behind the scenes (problems always come up, despite the original developer's best efforts to minimize them).

A generic/global social network API could be nice, but I still feel it would require learning the syntax and logic of the mashed-together object, further distancing you from the actual API implementation that is provided by each social network.

In the end, I don't know a better solution, unless the companies behind each social network come up with some sort of standard that provides more data than RSS, and allows you to also post data.

<div id="div1" onmouseover="myfunction(event, this.id);" onmouseout="myfunction(event, this.id);">
  <div id="div2">
    <div id="div3"></div>
  </div>
</div>

Notice the JavaScript events being captured on the outermost div: onmouseover and onmouseout, which both call myfunction().

Assuming all of the divs are of equal width and height, essentially they are "stacked" when displayed. There is no way to decipher the top element from the middle or bottom ones, since they are all flush with each other.

So when you hover over the top element, you are also hovering over the middle and bottom elements at the same time. Except, JavaScript event order dictates specifically when each element considers a mouse over as occurring (along with other events like mouse out, click, etc).

To be more precise, certain browsers consider the outermost element as the first one to react to the mouse being over it. Then it immediately cascades down into each sub-element and triggers the mouse over event. Other browsers consider the innermost element as the first to react to the mouse over event, and then proceeds upward to the outermost element.

The important thing to note (which was the root of a recent problem of mine) is that once the next element (in the stack) reacts to the event, the previous one also reacts to another event (mouse out) even though you didn't physically move the mouse away from the elements.

So the effect was multiple/repeat mouse over/out actions running, causing a seriously buggy-looking interface, and a maddening development experience.

The solution

The solution to this problem is one of two things:

1. Learn how to properly trap and stop event propagation.
2. Use jQuery (which does #1 for you).

Option #1 can get pretty messy and time-consuming, so I've chosen option #2 as it saves me a lot of time.

With jQuery it's as simple as binding the desired events to the element, and propagation is handled the way you'd like.

$("#div1").bind(
  "mouseenter mouseleave",
  function (event) {
    myfunction(event, $(this).id);
  }
);

Instead of mouseover and mouseout, we use the jQuery-specific mouseenter and mouseleave which handle propagation correctly.

The problem/question is - how does one effectively manage their social presence online without having to decide which vendor to be locked-in to, and still be able to discover new networks without completely alienating their core group of contacts?

Personally, I hate that I can't leave certain social networks simply because my core group of contacts are there. Why is our social web presence dependent on which vendor we choose to maintain our profiles? Shouldn't there be a more open format/protocol to publish a social feed, where anyone can easily connect to you outside of a specific vendor's idea of what the social web should be?

Social networks don't speak to each other (at least, not in a way that solves the fragmentation problem), so they are essentially little islands of functionality conjured up by the creator(s). We are limited to what the creators believe a social network should look like, and how it should behave.

What if there was a way to remain social but not be a part of any particular social network? To have a public profile but not require an account, or web server? To allow others to easily connect with you, without looking up your old email address, or hunting you down some other way?

Let's face it - the larger Google, Facebook, and even Twitter become, the more it's evident they are companies concerned with their bottom line, not with the growth and expansion of human relations through what is essentially still an open medium, the internet. They are simply trying to monetize their social network implementation (aka business).

What's the answer? Is there a better way?

Opera Unite is kind of thinking along these lines, but it hasn't really taken off since it's release almost three years ago. The concept is to be social on the web, but not be a part of any social network. The problem is it requires using the Opera web browser, and it communicates with an Opera-controlled web server, meaning there is still vendor lock-in involved. What if Opera goes out of business? What happens to my social data?

Unfortunately, pretty much any channel that requires information passed around needs a centralized web server to handle this, and how do you achieve that without being locked-in to a certain company? Someone has to provide the infrastructure and resources.

The web may be open, but it's still run by corporations, you still need an internet connection and a device, which all cost money.

I guess I am getting too abstract here.

After my initial trial-and-error, I have yet to find a seamless solution, but I'll post what I've done so far.

I currently use TortoiseGit, and Pageant to store my SSH keys. I chose "TortoisePLink" during the SSH setup when installing TortoiseGit.

Pageant seems pretty straight-forward. You add SSH keys to it, and somehow it communicates with TortoiseGit when accessing GitHub.com.

The problem is when you need to access multiple GitHub.com accounts. You can add multiple SSH keys to Pageant, but it only seems to use the first one listed (the one at the very top):

I can't figure out a way to have it use a different key from Pageant depending on the TortoiseGit settings (for each local working directory).

I have two GitHub.com accounts - one for work projects, and another for personal projects.

I use the same servers to develop/deploy these projects, albeit in separate directories.

I need to be able to authorize myself (via SSH keys) to either GitHub.com account (and repositories within) on a per-directory basis, all on the same server.

It seems that the local git client wants to use the same SSH key every time it authorizes access to GitHub.com, rather than alternating it depending on the directory I am working in.

For example, here is an illustration of the setup on my server:

root/
  work-project/
  personal-project/

I want work-project to authorize to GitHub.com account A. I want personal-project to authorize to GitHub.com account B.

Multiple SSH keys

I've already set up multiple SSH keys - one for each GitHub.com account. Example:

.ssh/
  work_rsa
  personal_rsa

Both keys have been added to their appropriate GitHub.com accounts.

I've also already created a config file inside the .ssh/ directory with the following contents:

Host github.com
    Hostname github.com
    User git
    IdentityFile ~/.ssh/work_rsa
    
Host github-matthom
    Hostname github.com
    User git
    IdentityFile ~/.ssh/personal_rsa

I've also ran these commands:

ssh-add ~/.ssh/work_rsa
ssh-add ~/.ssh/personal_rsa

This should allow both SSH keys to be used, which it does, but only partially.

It seems like it only honors the most recent ssh-add command. In other words, as long as I run one of the above commands, I am then able to authorize to that GitHub.com account from that point forward. But as soon as I run the command again (for a different account), it then always uses that account to authorize. Therefore repo access attempts fail because it can't authorize the other user.

I can't figure out how to have it automatically know which SSH key to use based on the directory I am working in (since each directory is associated with a different GitHub.com account/repository).

UPDATE (12/31/2011)

I seem to have figured it out, thanks to this site.

I re-configured the names of my SSH id_rsa files:

.ssh/
  id_rsa_work
  id_rsa_personal

Next, I updated the .ssh/config file to reference the new file names:

Host github.com
    Hostname github.com
    User git
    IdentityFile ~/.ssh/id_rsa_work
    
Host github-personal
    Hostname github.com
    User git
    IdentityFile ~/.ssh/id_rsa_personal

Notice, in particular, the second Host listed:

Host github-personal

This matches the file name id_rsa_personal. This also matches the actual GitHub.com account name (Note: "personal" is just used as an example, and is not my actual GitHub.com account name). So you would include your alternate GitHub.com account name here, as such:

Host github-ACCOUNT
    Hostname github.com
    User git
    IdentityFile ~/.ssh/id_rsa_ACCOUNT

Next, make sure the directory you create on your server is pointing to the appropriate GitHub.com account:

git remote add origin git@github-ACCOUNT:ACCOUNT/test.git

Again, replace "ACCOUNT" above with your actual GitHub.com account name, which should match the same name you referenced in the config file.

Now you can pull or push to that GitHub.com repository, and it will always use the correct SSH key.

I don't think you need to run ssh-add ... anymore, but it doesn't hurt to do this as you can save time from having to re-enter your SSH key password repeatedly.

Let me know if anyone notices any errors in my explanation, or easier ways to handle all this.

UPDATE (01/03/2012)

I forgot to mention I also had to add a .bash_profile file at the root of my server, containing these contents:

SSHAGENT=/usr/bin/ssh-agent
SSHAGENTARGS="-s"
if [ -z "$SSH_AUTH_SOCK" -a -x "$SSHAGENT" ]; then
    eval `$SSHAGENT $SSHAGENTARGS`
    trap "kill $SSH_AGENT_PID" 0
fi

Otherwise I could never run ssh-add.

So the concept of TwitWipe (which is horribly named by the way - sounds like something you do in the bathroom) sounds interesting.

From the service:

"Why the fuck would I want to do that? -- TwitWipe is a tool to wipe or delete all your tweets in one go. You may need to do this to start over, to clean it out before handing the account over to someone else, or maybe you've just realised how shitty your tweets are."

Also:

"How long does it take? -- A FUCKING LONG TIME. It is NOT instant. It will take a while. Don't tell me it's stuck at 0, because that happens and all you gotta do is WAIT."

Definitely charming answers, and possibly a very useful service.

– Via Mashable.

I talked a little about the web becoming more passive, in that the more devices and applications that connect to the web become available, the less effort it requires of us to interact with the web. Eventually the web will be omnipresent - instantly available for us to interact without retreating to a specific device or portal to initiate that interaction. As the air is all around us, so will be the web.

We're already seeing some of this happening with automatic sharing, such as how Spotify shares songs you are hearing to your Facebook stream without you manually initiating the update. It just happens in the background.

Digg is also starting to share links to Facebook automatically.

This type of fluid sharing removes the barrier of always having to initiate sharing manually, and allows us to interact with our web and social world at the same time.

It also requires a little more awareness on our part to which services are automatically sharing, and making sure everything we do online is something we don't mind our social networks seeing right away. If we're careless, we could end up sharing some embarrassing or sensitive information.

Some may think automatic sharing is too intrusive, and long for the days of private online activity, but I think we'll get used to this new approach as it allows us to merge our web and social worlds without additional effort and minimal compromise.

I felt a lot of it was just too predictable or impossible (plot-wise). For example, somehow Dexter never gets tired and is always in the right place at the right time. Everything (information, clues, etc) just came to him, instead of him working hard to get it. Also, the human side of Dexter seemed less-so this season.

I find it funny how Harrison's babysitter works practically around the clock. Dexter goes to work all day, then stays out most of the night. The babysitter is never tired or irritated with Dexter. That is some level of patience she has. Dexter must be paying her well. The babysitter is practically Harrison's mother at this point. Dexter seems to only be a father when it's convenient for him.

--

And then the finale. Here are my scattered thoughts:

Only one cop staged on the roof of the building? He doesn't respond right away during the first roll-call, but no one seems to bat an eye. You would think if the first roll-call receives a delayed response, there could be a problem? Maybe send someone up to make sure everything is okay?

Lots of gaps. How does Dexter know Travis is on the roof? How on Earth does he get around town so fast? How does Dexter get Travis from the roof to the church without being noticed (when there were police staged all around that building)?

The "sleeper" character could have been the therapist for Deb, as she convinced Deb she could be in love romantically with Dexter. I know Deb has seen a lot, but I don't (for Fuck's sake, as Deb would say) believe she thinks she loves Dexter romantically. But maybe the pressure of being lieutenant had something to do with that.

Since Deb's guard is down by being in love with Dexter, the final blow is not as bad as Dexter being caught by authorities, even though Deb is very high authority. Since Deb has emotional ties to Dexter, this is not a cop catching Dexter, but a family member. I would have rather Doaks, Lundy, Quinn, or Jimmy Smits help catch (and prosecute) Dexter, but now that Debra has, you gotta wonder what angle the writers will take with this.

Deb is either going to blame herself for constantly falling in love with serial killers and fuck-ups, and possibly become suicidal... or perhaps side with Dexter and understand what he does (as Lumen did).

Perhaps Dexter's "dark passenger" is just what Dex and Deb need to become closer, on a level no viewer could foresee happening.

I guess I have no choice but to anticipate season 7, but here's hoping it's vastly different from the usual Dexter routine.

A good example is when I am searching for lyrics to a song. At least the first two pages of results are filled with noisy, ad-infested sites that make it extremely difficult to view the actual content I want to see. But if I navigate to page three and beyond, I find some very minimalistic sites that quickly display the content without bombarding me with pop-ups and other such nonsense.

In this manner I am purposely looking for less-optimized sites because I know they'll be more reader-friendly.

It's gotten to the point where I almost never trust the top sites anymore.

Sometimes even the most organized and humorless programmer (I'm thinking dry, nerd personality) feels like being sarcastic or witty at times.

I've seen anything from a few words to paragraphs of off-beat ramblings or humor. One guy I worked with wrote a few paragraphs to explain the exact moment he thought of the following code/logic. It started along the lines of, "I am eating a pot-pie and sipping a Pepsi a few days before Christmas..."

Some comments are not even intended to be funny, but read out of context or by someone else trying to figure things out, can be very funny.

I started pooling some of the shorter comments together for a comprehensive list. If you have others, please share.

// gather important data

// 2do

// it should never get here!

// not sure what is going on here

// Well, this is weird.

// Shouldn't happen, but...

// do something else here?

// oops

// nothing happening here, just let it pass (symbolic, eh?)

Much like my indecision over blog categories, I have the same issue when organizing my music into playlists.

My problem is that I have trouble sorting (in my head) how I prefer to listen to current favorites, and past favorites, while maintaining a genre separation for different moods.

For example, I like classical music when programming, but not when working out. I also don't need to hear a favorite song from months ago all the time, but I still want to revisit it occasionally to recall the time and place (in my life).

So I've established playlists that capture when I first heard (or started liking) a song. I organize them into month/year playlist names. Anything I like that month goes into that playlist.

Yet some of those songs could also fit into my "workout" playlist, or my (yet to be created) "programming" playlist.

So there's some cross-over that I don't know how to handle.

Then there's some days that I create completely customized playlists out of the blue.

Maybe when Spotify includes "smart playlists" (like iTunes does) will this issue be more manageable.