madhouse

I'm doing the same. I just share the link to the appropriate circle (I have a ton of overlapping circles - I'd rather select one circle from a long list than build up my share targets from small distinct circles) and voila.

They immediately get notified, and if they reply, I get a notification aswell, and neither of us had to leave the browser. With the G+Me chrome addon, this is all painless and straightforward.

The video was okay-ish, but the lack of _any_ kind of reasonably content on their website was a big let down. I tried to request an invite anyway, for the heck of it (I usually give these things a try, when they can present something marginally interesting), but if they don't want my email address... well, I'm not going to force them to have it, either.

It did not accept my perfectly valid email address, just because it had a + in it. Not impressed.

What may seem easy, may not be. When written down and explained, things often sound trivial (so do the Anonymous hacks too), but it often takes a lot more than trivialities to actually do it.

They're not super smart, nor are the Sony developers/admins super incompetent. They're just average people making mistakes or taking advantage of others' mistakes.

Could Sony have done better? Yes, of course! They made some very stupid mistakes. Does that make the admins incompetent? Not necessarily. Nor do the holes in their systems make Anonymous super-smart.

It's still a pain to archive, and requires extra network roundtrips even in the best case. I not only need to be able to access my mail host, but wherever else the link is pointing to aswell.

When I'm checking my mail on my mobile phone, I'm sure as hell do NOT want to make extra network roundtrips just to be able to see my mail.

It's also far harder to index, sort and search in the proposed scenario: while I can quickly file an email under any label or folder I choose, and be sure that it will stay there, have the same contents forever, and I can search it easily, the proposed scenario does not allow for that. While I can still file and label the emails that have the links, I cannot easily search in the contents, unless I archived that separately, or I go online.

Again, a lot of indirection for no real gain. I can already use something like http://gist.github.com/ or the various pastebins, and a multitude of other solutions if I have a particular problem where they are appropriate.

But for everyday mail? Why would I want to do that? It just makes things more complex, for no purpose or gain at all in the vast majority of cases.

I opted to press the "Delete account" button instead. No nasty surprises like this one then.

So far, it seems to work.

So, there'd be another layer of indirection, and not only would I have to download the email, I'd also have to fire up a browser?

And the link would point to something that's never guaranteed to remain there, or remain the same? Something next to impossible to archive or download for later reading?

No, thank you.

If I want a collaboration platform, I will use something that's designed to be one. I want my emails as emails. Something I can store on my computer, something that does not change. Something I can archive, and quote from later.

If she's in the arts, she already understands computer science. She just calls it by a different name: art.

It's no more different than how a poet differs from a sculptor: their ways are drastically different, but in the end, both are artists. So is a good computer scientist.

I programmed quite a lot in both Perl and Python. Both have their ups and downs, but - as mentioned before me - while Python may seem cleaner and better on the surface, it can - and often is - made into as massy as anything else.

Some of the python stuff also makes me want to go to a corner and cry (significant whitespace being very high on that list, the GIL being another pain in the backside at times, and some of the python modules are so very poor it's not even funny).

In my opinion, the horribility of Perl is greatly exaggerated. As for good perl coders out there - I have no about that. I'm on the opinion that a good programmer is mostly language agnostic, and can pick up a new language very fast. If you look for those, it won't be too hard to find a few that's willing to speak perl.

Since I put every interesting thing I do (be that code, documentation, poetry, blog entries, or just random stuff, including pictures I take) in git, one could count that as a kind of diary.

I've been keeping such a thing for over a decade now, first in CVS, then in TLA (aka GNU Arch) and now in Git.

All my mails since about 1998 is kept and archived aswell.. and the reason I keep everything, and store them in git, is because I have an unnatural desire to cling on to every bit of stuff I wrote, every discussion I've been involved in, and so on. Having it in git also allows me to easily replicate all or parts of it on my different machines, as a cheap backup solution.

You could even use something like "Accept: application/vnd.text+json;api-version=1". Personally, I'd go with the custom Accept header, using the same type, but different "accept-extension" (see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for details).

Personally, I find the syntax horrible. A good few years ago, I wrote reasonably complex stuff in Lua (a game addon, you wouldn't have guessed, right? :P), and it was quite painful to do that.

It doesn't help that it's embedded into larger applications most of the time, which do not allow easy debugging, if at all.

No deadlines, no stress, no ice cream :(

$ ssh root@router # ifdown -a; ifup -a

Oops.

As far as I see, this only applies to registered users, as it talks about accounts and whatnot. You don't need that for ye' olde search.

Well, just 'coding' IS boring. The fun part is figuring out what and how to code.

In my job, for example, I fix bugs. While that sounds terribly dull, it actually is not: I get to see a lot of interesting code, that's broken is so subtle ways that most cannot even imagine. I get to work with code written by a lot of very different people, in a lot of different languages. I get to study how these programs interact, how they form a system, how they work together, and why a little tweak here and there can make the whole thing fall apart, or - in the good case - perform much better.

Debugging all the weird problems, diving into assembly on architectures you didn't even see is very interesting to me. And once I come up with a clever fix, that feeling is amazing.

But this isn't your average code monkey job. Those are boring indeed.

I was like that when I was 20, except for the art stuff. I write code, that's what I'm good at, everything else is uninteresting, therefore I fail at it horribly.

Nevertheless, ten years later, I have a good job, which I absolutely love, and even when I leave home, I can barely wait the next morning so I can come back in and work. (Ok, it's not THAT bad, but you get the idea!)

And whenever I ask myself "what the hell am I going to do when I'm 40?", I know the answer: I'll still be working here, still be loving it. Perhaps I'll have a mid-length tie by then, perhaps not - I'm not worried.

Life, and jobs aswell, has its ups and downs. Starting a career is usually a bit of a downhill ride at first, but don't worry, once you find that one thing you were meant to do, these questions about the future will vanish.

Most probably, it's compressed (and obfuscated). Therefore, it's just a random combination of letters and hyphens, without any meaningful pattern.

For a long time, I've held the opinion that once one learns to write programs, the choice of language dims away, it's just a codification of the program. One should use whichever is most appropriate for the task, and whichever he's most comfortable with.

Thus, knowing more languages, and actually enjoying most of them, with little to no bias, is a good trait to have, in my opinion.

I found that reading good books helps a ton. Dry, purely technical books are no good to me: I put them down at most halfway through, because I forgot how it all started.

A good book will keep me amazed from the first page to the last, even if it's a programming book (FYI, Learn You a Haskell for Great Good is such a book - wish all of them were of the same quality), and I won't find it hard to remember what I read a day before. When the author makes the book interesting, I found that it sticks to me much more easily.

So, find good books, that are a joy to read, and you'll have a much easier time absorbing their content ;)

I've had a couple of "ah-ha" moments during my career so far. The first was when I noticed that "hey! I can WRITE programs myself!". That was one of the happiest weeks of my life: my father showed me how to write a very simple C+4 BASIC program, a dancing stick figure on the top-left corner of the screen. I spent the rest of the week drawing different things and 'animating' them. That was somewhere around 1987 or so.

For the next few years, I played around with C+4 basic, didn't do anything serious. But in 1991, we got our first PC, and I tried to port the stuff I wrote on the C+4 to gwbasic, and later QBasic, but didn't succeed. So I dropped basic, and tried Turbo Pascal. That was my second ah-ha moment, when I discovered its help.

By 1998, I was reasonably fluent in Pascal and 386 assembly, but then my harddrive crashed, and I lost everything I wrote and collected since '91. That's when I installed Linux, and started to poke around with Perl (we had internet at school, and it was full of perl scripts. I choose perl because that's what I found the most resources for), and I discovered regular expressions: third ah-ha moment.

The fourth ah-ha moment was when I started to play with esoteric languages, which in turn resulted in learning a couple of other, real and interesting languages aswell. And then I realised that hey, I can program! And I don't care what the language is, once I knew a few, I could very easily learn another!

That moment was when it dawned on me, that programming is something much deeper, and something much more than simply writing code in one's language of choice.

And then I found the "Learn You a Haskell for Great Good" book, and when I finished it, I was enlightened.

I'm an Emacs user. I love my editor (or OS, as some would think of it) because it has everything I need to do at my fingertips: no matter what I do, I hardly ever need to leave it, if at all. That way, I have familiar keybindings all over the place, it's scriptable and extensible, and documented better and more extensively than anything else I've ever seen.

I can browse a projects git history, and follow bugzilla links, for example (it's even possible to set things up so that different projects will lead to different bug trackers). I can also easily poke around in said history. I can find functions defined in a whole other area of the projects by using etags. I have an integrated debugger, which shows everything I need, and more. I have an email client with a ton of goodies (gnus threading is awesome, so is scoring and a lot of other things).

And I could continue virtually forever, but in the end, the reason I like Emacs is that it provides a familiar and integrated environment for every single task I can think of, and it lets me extend and enhance it at my heart's content.

Emacs, git, Chrome, zsh, along with my development environment (gcc, pyhton, autotools and whatnot).

There's like.. hundreds starting each minute. You might wish to be a tiny bit more specific.

The best course of action would be to sync your imap folders to a local server (OfflineImap with dovecot is an amazing combo). I'm using Google Apps like that, and it's blazingly fast. It does eat a lot of disk space locally aswell, but that's something I can afford for now.

However good and useful your search engine may be, in my Chrome, the whole initial page ends up in the top left corner, while the rest of the screen (about 5/6 of it) is completely blank. And when loaded, the search box doesn't have focus, so I have to move my mouse all the way up to the top left area, and click there.

Sorry, I'm not going to play with, or try anything that looks so awkward and out of place on my screen. Perhaps later, when the design and usability is better, but as long as the interface irks me, I won't care about the underlying features, either.

For the record, I'll state that I do not run a startup, nor have I influence in any larger business, so my comments should be read with that in mind. However, the company I work for, does release open source software, and it's licensed under the GPL (or a mixture of GPL and LGPL). If I ran a business, I'd do the same.

The reason for that, is the viral nature of the GPL: it's not friendly towards closed source, which is exactly what I want. If I, as a business, release a piece of code, then I want to benefit from any enhancements others make to it, I want to have the option, to take those modifications, and incorporate them into my version. With the BSD license, I'd be at the mercy of others, they may opt to contribute their changes back, or they may choose not to.

I don't trust most businesses, so I do not want to let them have that option: if they use my open source code, I want to have their modifications too, so we can mutually benefit.

Thus, for me, freedom of the code is more important.

I'm a big fan of git, and the branching model explained here: http://nvie.com/posts/a-successful-git-branching-model/

The closest thing I use to see stats-like output is the Impact graph of github, but even if I look at that graph, it's mostly an "ooooh, look at that, shiny!"-type of thing.

Creative Commons CC-BY-NC-CA (http://creativecommons.org/licenses/by-nc-sa/3.0/) comes closest, I believe, even closer than the GPL, but it might not be as good for software as the GPL is (I've never used a CC license for software).

Other than this, the GPL(v3) is the closest thing, as has been said before.

However, the downside of restricting it to non-commercial use is that hardly anyone if at all will use your software, and it probably will never make it into any of the mainstream distributions, rendering it fairly irrelevant. I don't think that's worth the price, so I'd go with the GPLv3.

While I'm not an autotools fan by far, after reading through the linked post, I could only cover my face with my palm. There's quite a few things he lists as autotools shortcomings that's not it's own fault, but that of badly written configure.ac or Makefile.ams.

Basically, at least half of the problems he lists, is due to badly written configure.ac/Makefile.am, and not an issue with autotools themselves. Cmake lets one do stupid things aswell - it is no better in that regard.

Not to mention that some of the suggestions are downright unportable to non-GNU systems.