Jackson's Blog

For this post, we’re comparing Google, CNN, and CBSNews.

I am very disappointed in both Google and CNN, but frankly quite impressed with CBSNews. In this modern day and age, when the word “real-time” is used, we no longer expect the need to refresh the page, and CBSNews has risen to the occasion. CNN’s flash based website requires a page refresh in order to load the data. Google on the other-hand, at the time of this blog being written, isn’t even working.

Not only are page refresh yesterday’s news, but it also consumes more bandwidth because you’re loading the entire page, not just the part that changed. They should seriously put more resources on pages they expect a lot of people to see. I can expect CNN, a news site, not having the most “1337” (elite) programmers working on their site, but not Google. I’m frankly quite disappointed.

It’s this growing expectation that visitors have of web functionality and the lack of it that reinforces my belief that web development is still an increasingly important field.

So yesterday, an hour before a schedule meeting to discuss a project, the General Manager in charge of all development told me that I’m charge of this new project and that I’m the lead. Not only that, but he wanted me to go through all the relevant documentation regarding this project and take charge of the meeting.

It was like being hit by a tornado and then struck by lightning.

I used my hour to hastily skim through all the documentation and requirements. Then I came up with a list of relevant and informative questions, a strategy on how I’ll divide the work up between my team-members and I, and started the meeting.

Overall, it was pretty awesome. I have good members on this team, and I’m more than certain than we’ll complete this project with flying colors. Although now that I’m lead, I’m starting to feel their responsibility and trust that they must place on each one of their team-members, I can see how it could be nerve-wrecking at times.

The web is becoming more and more populated web applications. We have social networking tools, we have web-based email clients, even web-based Microsoft office, and last but not least, we have a super powerful repository of knowledge (Google).

What do all these web apps have in common? They’re all free.

The great thing about a free web app is that it has the ability to create returning traffic. Just like how returning customers are very valuable to a store, returning traffic is the web equivalent. This fact alone wouldn’t make any economical sense, but after you figure out the marketing implication of a massive amount of returning traffic, that’s a huge amount of possible ad exposure, and that’s where free web apps make their money, off advertisement.

This is why free apps like free public television will continue to make sense. Certainly we’ll have to endure some ads every here and there, but they’re a small price to pay for what we’re getting.

So at my work, they’re currently thinking about implementing a new feedback system so that the employees can know about everything they’ve possibly done wrong. I don’t know any developers that can possibly avoid a “you didn’t work hard enough”, or a “you didn’t code well enough comment”. There isn’t a day I go by where I don’t look back at my code and say to myself, “I could’ve coded it better”, or felt that I could’ve gotten more out of that day. This is part of a programmer’s growing process. The issue I have with implementing an impersonal feedback system is that I feel it might do more harm than good.

On the plus side is that it can highlight all the weaknesses of the programmer, but depending on how you highlight those weaknesses, it can be a boon or a detriment to the programmer. A good manager can ascertain to whether or not these “rumors” are true, where they exercise to their best judgment on feedback that would be beneficial and those that wouldn’t. They can determine what will be the ultimate result of such comments, a systematic approach won’t. There are ultimately negative feedbacks that might have a positive effect, and there are ones which won’t. An example of a good negative feedback would be “you should try better to adhere to the coding standards we’ve implemented”. An example of a bad one is “you’re ability to code clean and efficient code is questionable”, or possibly, “people in your team have said you act overly confident in everything you do”. You effectively turned a friendly supportive environment into a hostile environment, where everyone is watching out for themselves and themselves only. They keep words and thoughts to themselves, very careful of expressing the lack of knowledge in fears that someone would give them a negative feedback regarding the code, even worst, if they were quiet and kept to themselves, they’ll be slapped with a “lack of communication negative feedback”. The moral of the story is that unless you’re perfect, you’ll most likely get negative feedback, and even if you’re near perfect, you’ll still get negative feedback. This impact to the confidence in yourself, and in your environment can’t be a good thing. So before the implementation of this system, I’ll like for it to be carefully reviewed.

I believe the team lead should be assigned the responsibility of providing feedback on the programmers under him. I believe he should be more than sufficient due to the fact that the team lead is in a position where he can oversee the activities and determine whether or not these activities have had a negative, positive, or no impact on the project. Due to his experience and ability to empathize with the developers he can also determine whether or not such activities are necessary or unnecessary and then advise accordingly.

Although I’m not sure if this system would be without its faults, I do believe a system where the team lead will take charge of growing and shaping his men makes more sense than having his men grow on their own by attempting to avoid random stray bullets flying at them.

Today, the world has lost a great teacher and programmer. I can’t help but admire him for the things he decided to do given only 6 months left to live. Instead of succumbing to pre-mortem type activities such self-pity, he decides to keep doing what he loves to do, educating young minds. It’s amazing how he displayed so much energy and life during his lectures, despite having terminal cancer. Instead of dealing with his morbid situation is a sad and depressing way, he decides to make light of it. The things he did were amazing and his words were jewels of wisdom. The world of programming, if not the world, is going to miss him.

If you are familiar with a MVC framework you can skip this paragraph. There are two components to this term “MVC framework”. First, a framework is a code-base that strongly suggests that you code using certain methodologies. Obviously, generally frameworks are designed to help the developers code faster, more object oriented, reduce code redundancy (encourage code reuse); a bunch of good stuff. There are obvious negatives to frameworks as well, which is why finding a good framework is important. Certain frameworks might be too rigid and cause very simply things to become extremely complicated. Other frameworks might be too lax such that it no longer serves a purpose of a framework. Next, MVC is an acronym for model-view-controller. It’s coding approach that separates business logic, template, and the logic which combines them into three different components. The business logic is generally in charge of generating the data the MVC application is going to employ. The view uses the data the controller passes it to generate the things you’re supposed to display on a screen. And finally, a controller is pretty much a component that mediates between the two, basically, tying in the business logic to the template in order to generate the final page. Because the code is broken down into smaller more reusable parts, and then they’re generally reused, which saves the next developer from coding the same thing from scratch.

In an MVC framework, I believe if an instance of a model is created and then passed to the view, the instance should pass from the controller to the view unmodified. One of the reasons you’d want an object passed is because objects are supposed to have a predictable behavior. I can rely on string to be accessible like an array of characters. It gets weird when I’m supposed to access a controller modified version of the string to use something that might or might not be there depending on the logic employed by the controller. So in conclusion, if you find yourself modifying an instance of the model during run-time, you’re better off not altering the instance of the model. You can simply pass the parameters directly from the controller, or define it in the view.

People wonder if Facebook will overtake Myspace. The answer is I doubt it. Facebook’s strength lies in its simplicity, whereas Myspace’s strength lies in its ability to be “personalized”. As long as the two sites maintain their course, I doubt one will overtake the other.

I originally would have made the same argument about Microsoft, Apple, and Linux, but because Microsoft is starting to lose sight of what made it Microsoft, it’s starting to lose ground to Apple and Linux. They bragged about how they had advance graphics, the problem is, Macs and Linux OSes can do the same thing with a fraction of the system requirements. Vista is overly bloated and annoying to use. I personally think that if Microsoft maintains the course they did with Vista, more and more users will contemplate switching to Macs or Linux boxes.

So yesterday, we divided into my theory of how Google work, but today, we get to see the inner workings of how Facebook serves a picture. I came across a very interesting presentation. The presentation shows what kind of technology Facebook uses, how they customize their own kernels, file systems, use CDNs (Content Distribution Network), caching, and etc to improve speed. I guess for starters I’ll have to explain how the internet works before I even get around to explaining one of the roles CDNs play.

“The internet is a bunch of interconnecting tubes”. Although this doesn’t fully do the internet justice, I can see how it might make sense to others. The internet is really a series of interconnect computers. You have thousands and thousands of computers connected to each other all across the world. The interaction between computers generally consists of interactions between a server and a client. The further the server is from the client, the more computers it’ll have to go through to arrive at the client.

A CDN is a network of computers that are generally well distributed for the region(s) it serves. These distributed computers cache or save the information that are frequently requested and act as a server for such information. What this does is that it prevents a client computer from having to wait for the data to come all the way from that super far away server. Obviously, there are other uses besides speed, such as preventing the system which generated the content from having to regenerate redundant information a second time.

So in the Facebook’s image serving system every picture gets cached at three levels, according to the lecture; once at the CDN level, once at memcache, and once by MySQL. Although later on, the lecturer says two. In this case the most important reason for caching is to prevent disk reads or MySQL requests. If the request matches something in the cache, it simply returns the information which it has stored in the memory, bypassing any disk reads or MySQL queries. If the requested information isn’t in the cache the server will then perform either a disk read or a MySQL request, which on a heavily trafficked system can the be difference between a split second or 5 seconds. In this case if the information isn’t cached the server hits the “Net APP” which I visualize as a massive central database to request the file’s location. This file location information is then used to retrieve the file requested. This file gets sent back to the user through the pipeline again, but is also sent to the cache to be cached.

Their cache system uses a most accessed last out system. What this mean is that the more the image gets accessed, the longer it stays in cache, which simply makes sense.

The lecture also goes into how they created their own file system and kernel and the reasons why the needed to create their own file system and kernel.

It was a very interest lecture, I recommend my readers to check out.

http://static.flowgram.com/p2.html#2qi3k8eicrfgkv