Here is how to look for all occurrences of a domain name on the social bookmarking site delicious — search for “domain:grok2.com” (replace the domain name with the domain you are looking for) using the search entry field. An interesting feature of this is that you can see some trend statistics and the various tags used when bookmarking pages on the domain.
“We are what we repeatedly do”
— Aristotle (supposedly)
Seems like Bing is losing steam … “Searchers used Bing less in September than in previous months, ending three consecutive months of growth” — from InformationWeek.
I wondered if one can hold multiple Google Adsense accounts. A quick search revealed that Google’s answer is “maybe”. What they don’t allow is for the same payee (to whom they make out the checks) to have multiple accounts. So perhaps you can work around this by creating accounts in other people’s names (your better half perhaps?), but there are tax implications. I have also read that sometimes there are problems with different payee’s being at the same address or logging in from the same machine (or IP address) though this could just be fear-mongering. Simply send an email to Google Adsense support and ask them. One thing they do seem to allow after approval if you are a business entity is to hold Google Adsense accounts in the names of each of these business entities owned by you.
See Google Adsense Help question: “Can I sign up for more than one account?“
I wondered if Bing was run on Windows servers (that would have been an excellent demo of Windows Server). But checking on NetCraft seems to indicate that bing.com is hosted on Akamai‘s servers and Akamai probably uses Linux based hardware and software. I guess it makes sense that a company with lots of money would spend that money to not have to bother with the scalability aspect themselves :-). But hosting on a Windows back-end would have been a great demo.
As a programmer, you are continually making decisions when you program. Both at the macro level and the micro level. For any project, you have to select the programming language, the tools and the environment. Then as you design, you have to choose continually among multiple ways of doing anything. As you code, you continually are choosing among many ways to write the code. You are continually reformatting and rearranging code and even refactoring because you are not able to decide if one way
is better than another. The problem is that, usually, the decision making required is trivial. But the sheer number of times you have to decide stuff is what slows down any programming task.
I think people who complete / finish projects are people who do not sweat over all details when programming. For most decisions, when the need to make a decision arises, they quickly choose one of the two or more choices without thinking about it and do not second guess their choice. So they continuously make progress and take one path to the end — they do not spend their time vacillating over what to do at each decision point. If some decision was really bad, it will become apparent enough — then you only need to decide (:-)) if you need to rewrite the part of the code starting from where a wrong decision was made.
Google search revealed that “bis” means “twice” in Latin and the bis in 2547bis refers to the fact that this is the 2nd edition of the original 2547 RFC with updated sections. Who would’ve thunk?
You can start Chrome in the Incognito Mode (called Private Browsing by IE) by providing the command line switch “-incognito” when executing the Chrome binary.
The author of this coins a new phrase — Premature Flexibilization:
…the practice of adding complexity to your code to make it more “flexible”, in anticipation of future change.
The article, triggered an “yes” response in me 🙂 because I felt the same way many times.
In all my coding, I find that I waste a lot of time doing exactly what the author of that article calls “premature flexibilization” — trying to make code as generic as possible, trying to cover many cases that are currently not present, trying to cover all kinds of input. Though it is a good habit, I find that it contributes negatively to project completion and most times, all the genericity, etc was really not used. I have found that it is better to follow the agile practice of YAGNI and code to the current exact requirement and later go back to refactor code when another requirement for the same code comes it to make the code flexible and generic to cover the original and new cases. That way the code goes organically, does exactly what is required and the project gets completed.
One thing though is that it requires some discipline when revisiting the code the second time around to make sure that you test the original requirement is still being met.
I think one of the reasons for the effort spent in making the original code flexible is so that I don’t have to revisit code (mentally for me code maintenance is possibly one of the hardest thing to do).