Programming Matters

When the web was young, backlinks were the perfect way to measure a sites popularity. The sites with backlinks were more popular and the sites with backlinks from more popular sites were even more popular as you would expect. And all was well.

But in today’s world no matter how much bleach you apply to your white hat, you can’t get around that little bit of knowledge you’ve acquired. Backlinks = success on Google. And by knowing this and “exploiting” this you will knock out those websites that don’t attempt to do any “SEO”. Your white hat may look white, but really it’s gray. You will do all the right things to generate backlinks. Invariably as much as Google would hate to admit it, this breeds a competitive landscape. “You can’t win if you don’t play.” It has now become essential to “ethically” build backlinks in order to get organic Google search results. And this is very bad for the quality of links on Google’s search results.

No matter how innocent you try to be, the cat is out of the bag. It is far to easy to get a large number of “encouraged” backlinks to a given site. When you search on Google the really big players come up first. And this is good. They have such a huge number of backlinks that they can pretty much be seen as genuine. It’s the middle ground. The “long tail”. These are the problems. If a smart developer/designer releases a Wordpress theme with a backlink and that theme is used by several hundred people they get lots of page rank. These wordpress themes can be used on popular blogs with plenty of pagerank themselves. This is “white hat” activity. But it’s really intelligently gaming the system. The SEO gurus know plenty of tricks to get backlinks and PR.
Because of this many Google “long tail” searches that are more specific are filled with SEO’d sites both white hat and black hat spam. I know quite a few people who actually are switching to other search engines because of the “backlink” spam. “Quality backlinks” are just too easy to get, especially if you are willing to pay money for them. And that goes on everyday.

Backlinks were a good idea at some point. Now they are only showing that you are trying really hard. The people that talk the loudest and the most often aren’t always the best. And proliferating backlinks to your site with all the right keywords to game the system doesn’t mean your content is the best either. It just means that you are good at generating backlinks.

Until spiders can have a clue what they are parsing it will be hard to impossible to solve this problem and still use backlinks.
Social networks like digg.com, stumbleupon.com and reddit.com are “the next new thing”. By having people vote on pages… the crap filters to the bottom. This of course will have it’s own set of problems - but invariably will be far better and more accurate than backlinks. At the end of the day some content will be brilliant and good - and still be undiscovered. However more data will yield better results.

How do you really judge the worth of a website? Is it how many people like it? The demographics of those people linking to worth for specific topics? How long people spend on the site itself? These are fascinating questions that search engines will be forced to answer in upcoming year - or they will be inconsequential.

This concept really applies to much of life, however, computer science in particular.

Why is is that new ways of doing things can have remarkable success when they are at “the discovery stage” and end up being useful but disappointing in the field? Object oriented programming turns into spaghetti class interdependencies and deep hierarchies in day to day use. A giant leap forward and two steps back. Software patterns turn into misuse and abuse of the Singleton pattern and inappropriate shoehorning. Extreme programming becomes an excuse to write unmaintainable code that passes each and every unit test. Simplicity becomes an excuse to build things so bare bone as to become unusable. It seems like each new “promising technique” becomes troublesome once it goes mainstream. Still worth the trouble, but troublesome all the same.

You may find yourself scratching your head about why such issues aren’t discovered before they gain mass acceptance. Why when things are in “the R&D” phase they perform so well. Even when these same things are tested in limited circles on “real world problems” they continue to seem like the next silver bullet.

The answer unfortunately is as hard to swallow as it is simple. Early on the people developing and working with these new technologies are quite often some of the best in the field and the smartest guys out there. By the time the concept migrates to the other 90% of the coding world it finds itself slammed against the middle and trailing ugly end of the bell curve. These portions of the curve will often times misunderstand and misuse the new tools and techniques presented to them. It’s during these phases that the backlash usually kicks in. Guidelines and rules must be created to keep the average programmer from hanging himself with too much rope.

Often times new paradigms go through a few separate stages of development and acceptance. In stage 1 the really smart R&D types hit it. These people are actually great at creating new solutions that are both groundbreaking and elegant. Once these “conceptual entrepreneurs” have firmed things up it is ready for stage 2. In stage 2 the brightest of the “real world group” is brave enough to tackle integrating these concepts into production code. They become evangelists of the techniques they have had so much success with. Stage 3 involves more risk takers embracing the techniques advocated by stage 2. They pour over the concepts involved, grok them and integrate them into their code bases. It’s at stage 4 that the tide starts to turn. At stage four the middle of the bell curve is beginning to be pierced. The new mantra is gaining success. By stage 5 you have everyone accepting the new paradigm as “the way to go” based more on appeal to authority and peer pressure. At this stage a significant number may not understand the new techniques at all. They will advocate them but only graft them on top of their existing ways of doing things.

I like to think of myself as a stage 3 integrator. At this point things have hit my comfort zone and they are worth a try. I will do everything I can to understand a new technique, but by no means have created it or been the true dare devil integrating it at stage 2 into production code. Later down the pipe when I see these concepts misused and abused - I avidly follow the “shoring up” techniques to keep people from blowing body parts off my misusing a new technique.

No matter what the latest silver bullet appears to be, it is merely getting it justly deserved 15 minutes of fame during its integration period. These techniques will live on but the focus will move on. It’s important not to throw the baby out with the bath water. New techniques may disappoint after several years of growth - but in the end they often stay part of our process. Object orientation, design patterns, components, agile programming, the list goes on. Don’t forget that silver bullets are still bullets even when they tarnish. Just because a concept hasn’t completely lived up to its hype doesn’t make it a great and useful part of your process.

GPU’s vs. quad processors

With dual processors everywhere and quad-core coming down the pipe - what will the future of custom GPU’s be on graphics cards? Something in my purest mentality has always disliked GPU languages from the get go. Pixel shaders may be one thing, but vertex shaders especially. It violates the concept that venerable old c delivered back in the day. Code portability and reuse. Now usually I don’t go insanely old-school to justify my points but here it makes perfect sense. I have already encountered plenty of situations where visualization was not enough, the CPU had to have access to the data in order to do analysis on it. The fact that operations could occur at one end of the pipe in a very proprietary way is more than a time waster from the standpoint of coding. It also isolates the results from being used by the CPU side code. In the simple case of shadow volumes with extruded verts jumping through shader hoops and trapping the data down the pipe seem to not be worth it IMHO. Back in the day (before 3D cards…before tight compilers) I would often write machine code to get the job done faster. But at the very least in this case the results where in fact something that other code could get access to.

I don’t mind custom processors for specialized purposes. Often the cost of these processors goes down nicely over time. But custom processors you are expected to program in a very atypical way. Time and quad processors will surely take care of that.

AdSense and curiosity

Never being a big believer in something for nothing Google and AdSense of course makes me skeptical. I do feel that inevitably this is the right way to go. People who create content shouldn’t have to worry about advertising it too. As a lark I’ve started playing around with AdSense just to get you the data. As part of the terms of use I am not allowed to report profitability information here, however I am simply dying to know. I do personally know people who have made thousands a month off of this technology. This of course is a skill-set in itself. As the web grows and matures I am sure that people who have popular sites and want to support there efforts with AdSense will be able to do so. But for now it does seem that engineering these efforts beats out honest attempts. But once again, the best way to know is to take a look. The question isn’t whether this is truly ready for prime time - the question is how far off it is. Some day I have no doubt that honest content authors will make comfortable livings paid for by AdSense alone. It’s exciting to watch this gather steam as inevitably it must.

Virtual machines

Lately I have spent a lot of time playing with virtual machines like VM-Ware and Microsoft provide. I’ve been curious about this for years. I remember a game I worked on in 2000 where we considered using VM-Ware to host Linux and Win2000 on the same box. We didn’t end up going with the solution but the debates were interesting. It certainly seems like Virtual Machines are progressing but having played in depth with VMWare I still have some major wishes. One is that it actually mirrored your bios and configuration. Having a generic VM seems to defeat some of the purpose. Also at some point if you could have mitigated access to 3D hardware. I still need to boot to new configurations when playing with XP vs. Linux 3D code and once again - this seems to defeat the purpose. We’ll see where it goes over time. But I certainly think it is here to stay - it earns it’s keep even at what still seems like early stages.

MSDN subscriptions and more

If it weren’t for MSDN subscriptions I’d definitely be taking a close look at Linux as a primary server OS and possibly even desktop OS. I never thought I’d say that. However the quality of Linux distros is so high now and the ubiquitous nature of the web so prevalent that I hardly notice when I’m running under Linux. Not so five years ago. But now - I am very intrigued. Projects like ReactOS (an open source Windows clone) blur the line further. And of course mono.net etc. bring all the “latest” technologies to the Linux world. I’m sure the “next wave” of amazing advances in OS are going to once again shake up the box a bit. But so far everything I’ve seen from longhorn doesn’t inspire me with the inevitable KISS principles that have proven to really make the difference to end users. I like the idea of native 3D support in the OS GUI. But I’m still not seeing the compelling factors here. The OS situation will continue to evolve. But the fight over features vs. clean simplicity is one that is still to be resolved.

With all of the latest talk about virtual machines no one can miss the impact they are bound to have soon. With dual core and quad core processors virtual machines will just be good common sense from a number of perspectives. One close relative of this that I have been waiting to come out of the wings for a while on is the truly transparent remote desktop. A world where you can go anywhere, log into your desktop and get the same experience as though you were right there. The only thing holding us back is bandwidth - but like everything else that fixes itself over time with minimal effort. The thought of running virtual pcs half way around the world on a remote desktop where the experience is truly seemless will change everything we know about computing. Web sites will be able to do things however they wish - they will merely be interacting with dumb terminals - pushing images back forth.

In other news - Google brilliance. Using KISS(keep it simple stupid) they implement only the bang for the buck features and go lightyears beyond anyone else in short order. I still underestimate them periodically. Google talk - yet another IM client. When I first saw it I shook my head and thought this is surely a sign of Google going downhill. After several months I have begun to realize how wrong I was. Ties to gmail were perfect but obvious. Chat history in gmail was more clever but still hinted at…. well yes I could have though of that. But taking your entire gmail list and showing the invited status of each of your contacts - brilliant. It creates the impression that it is already bigger than it is. I see a list in Google Talk that includes 20 people who are currently invited. I can’t help but think it is just a question of time until all of those people are using Google Talk. Microsoft proved more clever and agile than IBM back in the day. It certainly seems as though Google is proving itself more clever and agile than Microsoft. This will be no quick fix for Microsoft. By the time you are a force of nature - it is too late to reroute the butterfly wings that started you in the first place.

One of the better implementations of garbage collection for c++ can be found here:

A garbage collector for C and C++

I think in this modern day the time for automatic garbage collection for standard c++ is finally here. Manually reclaiming memory is both error prone and dangerous - calls to dead objects cause many of the surprise problems associated with c++. A number of sites provide details on how a concurrent thread for garbage collection actually provides superior performance to manual deletes. Proposals have been put forth for making garbage collection a part of the C++ standard and I am all for it. Other nice additions would be debug bounds checking for the stl among other things. I still love C++ but removing some of its thorns would give it longer legs in a world being overtaken by Java and C#.