Price

Google still hasn’t said how much Chrome OS machines will cost, but there are a couple things to remember: First, the operating system is free, so netbook manufacturers can dodge the licensing costs of Windows machines. Also, Chrome OS machines will run on solid state drives, which could drive the price up, but because there’s hardly any local storage involved, the size of these drives–and, therefore, the cost–will be minimal, and will decrease over time with no need to boost capacity.

The Cloud Rules

Eventually, Google will convince people that their data is safe in the cloud, mostly because Google users’ personal information is already up there. Yes, you’re in trouble if there’s some massive server failure, but what are the odds of that compared to your netbook getting stolen or broken? but you can always recover invoices and other vital documents from the cloud.

Market Strategy

Chrome OS will run on a set of reference hardware that will be developed and sold by device OEMs. Google is working directly with manufacturers to specify which hardware components will be supported. Conspicuously, hard drives won’t be on the list. Though the OS is open source, you won’t be able to download it and install it on any device you happen to have. Instead, you’ll have to run it on a Chrome OS-specific device comprised of hardware components that are explicitly supported by the OS.

One expected advantage of Chrome OS will be security. In contrast to the established PC model, in which applications run locally on the drive and user data is generally stored locally as well, Chrome OS will not allow applications to install locally or make changes to the operating system. At the same time, it will automatically sync all user data to the cloud. Meanwhile the operating system will automatically update itself all the time.

User data on every Chrome device will be encrypted, a move that is intended to protect users in the event that their device is lost or stolen. Matt Papakipos, engineering director on the projected, summed up this move by saying, “If I lose my Chrome OS machine, I should be able to go get a new machine, and have everything back up running in seconds” via the automated cloud backups.

Chrome OS “feels much more like a television than a computer.” Turn it, it starts right away, and you’re on the Web by default. In the demo, Chrome did in fact boot almost instantly on the Eee PC netbook. This is in part because the OS is just reading out of RAM rather than a magnetic drive. But there are other reasons that the OS boots and runs more quickly than most other PCs.

Chrome OS consists of custom firmware, a small kernel optimized to run on a short list of reference devices, and the Chrome browser. Because the list of supported hardware is short, the OS is designed without unnecessary background device support. This prevents the operating system from wasting time looking for devices that aren’t there (such as floppy drives), which is a problem with Windows and most other consumer operating systems.

Another aspect of the boot process enhances security. A verified boot process applies cryptographic signature keys to each chunk of code, so the the system can check the validity of module of the operating system before it is allowed to execute. In the event that some element of code doesn’t check out–due to malware or other corruption, the system will run an automated recovery procedure repair itself by redownloading the appropriate version of Chrome and reimaging the OS.

As an addition security measure, the root partition of the device’s drive is read-only, preventing any application from changing the core code.

The software will be initially be available by the holiday season of 2010 on netbooks that meet Google’s hardware specifications, such as using only memory chips to store data instead of slower hard drives.

Sundar Pinchai, vice-president of product management for Google’s Chrome OS, siad computers running Chrome OS will be able to start in less than seven seconds. “From the time you press boot you want it to be like a TV: You turn it on and you should be on the Web using your applications,” he said.

Ironically, google the search engine company, is gathering flack from the industry for not ‘googling’. According to reports, the company recently released its new programming language and named it ‘Go’. However, another language by that name already exists and even has a significant profile on Google’s own servers. The original ‘Go’ language creator, Frank McCabe, is apparently up in arms over Google’s ‘Go’, and is demanding the company change the name of its language so he doesn’t have to change the name of his own programming language. According to McCabe, he has been working on the language since 10-odd years. “There have been papers published on this and I have a book too.” he is reported to have said.

Go offers an expressive type system, fast compilation, good performance, and built-in language features that simplify threaded programming and concurrency. The language has been under development for roughly two years. It started out as a 20 percent project—time that Google’s engineers are given to use as they choose for undirected experimentation—and evolved into a serious full-time undertaking. Google is releasing the source code under the BSD license with the hope that a community will emerge around the new programming language and participate in the effort to make it a compelling choice for software development.

Go language itself and the current implementation are relatively mature, but it’s not quite ready for adoption in production environments. The ecosystem around the programming language is still a work in progress. There is no IDE integration, the standard libraries are a bit thin, and there aren’t a whole lot of real-world code examples yet. Opening up Go to the broader programming community could help to vastly accelerate its advancement in all of those critical areas.

The native Go compilers, called 6g and 8g (for 64-bit and x86), are designed to be extremely fast. There is also an alternative compiler called Gccgo that is based on the GNU Compiler Collection (GCC). The GCC-based compiler isn’t as fast but is said to generate more efficient code. I was initially a bit surprised that Google chose not to use the Low-Level Virtual Machine (LLVM) compiler framework—it has a lot of LLVM expertise internally and is using it extensively for their awesome Python optimization effort. Pike says that LLVM was considered during the early stages of the Go project, but its compile-time performance was judged to be inadequate.

The compiled executables are completely native binaries, so it’s not like a managed code language where the compiler generates bytecode for a virtual machine. Go does, however, have some runtime components that get embedded in the executables. Actual execution performance is said to be comparable to that of native C.

Some of Google’s sample Go code reveals that the syntax is C-like and encourages a conventional imperative programming style. There are functions, “for” loops, standard conditional expressions, and many other features that you’d expect to find in a C-like language, but with a handful of nice twists. For example, there is a shorthand syntax for variable assignment that supports simple type inference. It also has anonymous function syntax that lets you use real closures. There are some Python-like features too, including array slices and a map type with constructor syntax that looks like Python’s dictionary concept. The following code snippet is an example from Google’s documentation:

    package main

    import (
        "os";
        "flag";  // command line option parser
    )

    var omitNewline = flag.Bool("n", false, "don't print final newline")

    const (
        Space = " ";
        Newline = "\n";
    )

    func main() {
        flag.Parse();   // Scans the arg list and sets up flags
        var s string = "";
        for i := 0; i < flag.NArg(); i++ {
            if i > 0 {
                s += Space
            }
            s += flag.Arg(i)
        }
        if !*omitNewline {
            s += Newline
        }
        os.Stdout.WriteString(s);
    }

One of the distinguishing characteristics of Go is its unusual type system. It eschews some typical object-oriented programming concepts such as inheritance. You can define struct types and then create methods for operating on them. You can also define interfaces, much like you can in Java. In Go, however, you don’t manually specify which interface a class implements. Pike explained to me that the interface mechanism gives developers some of the flexibility of duck-typing, but it goes further by providing the advantages of compile-time checking.

Parallelism is emphasized in Go’s design. The language introduces the concept of “goroutines” which are executed concurrently. Any function can be executed as a goroutine by prefixing the function call with the “go” keyword. The language provides a “channel” mechanism that can be used to safely pass data in and out of goroutines.

For more details, check out the project’s official website.

Other parts of the new Noop homepage (which is hosted by Google Code) explain that Noop “in source form looks similar to Java.  The goal is to build dependency injection and testability into the language from the beginning, rather than rely on third-party libraries as all other languages do.”

Then, “Immutability and minimal variable scope are encouraged by making final/const behavior the default and providing easy access to a functional style.  Testability is encouraged by providing Dependency Injection at the language level and a compact constructor injection syntax.”

Google NOOP

The Noop website is pretty well built out if you’d like more information.  Google’s developers provided all sorts of details about the current state of things and where Noop may go, as well as a place or two in which folks can give feedback.

The new search engine is the redeployment of the computing network that Google uses to connect searchers and results. The search engine can change how the company ranks in its search engine. The companies will have to change their Search Engine Optimization(SEO) to protect their Google ranking.

Google is not changing the user interface as part of the Caffeine update. So the average user is not likely to be surprised by the way results appear. The update does not affect the ranking of ads on the search engine.

“For the last several months, a large team of Googlers has been working on a secret project: a next-generation architecture for Google’s web search, it’s the first step in a process that will let us push the envelope on size, indexing speed, accuracy, comprehensiveness and other dimensions,” wrote the company blog.

“Google makes constant changes to its search algorithms and infrastructure, but such a change in this magnitude has not been done since 2006,” said Matt Cutts, Principal Engineer, Google.

The search page is identical to the classic, clean Google web page.

Google is opening a web developer preview to collect the feedback regarding how Caffeine performs compared to its current search engine and is not looking for comparisons to offerings from rival internet firms.

Microsoft has been praising the momentum of its recently-launched Bing search engine and is believed to take long term approach for closing the gap with Google. Microsoft has also announced a tie-up with Yahoo. Google has a two-third share in the search engine market, as Yahoo stands second and Microsoft at third in a search engine market.

Here is the link on how you can access that.

The system is beta (of course) and accessible through Gmail Labs. But it won’t be immediately available to everyone – Google is parsing out access as it experiments with the new feature. I don’t have access to the new feature yet, so I’ve still got lots of questions. But Google’s post makes it sound like the experience will be almost indistinguishable from using Gmail normally.

“Gmail uses Gears to download a local cache of your mail. As long as you’re connected to the network, that cache is synchronized with Gmail’s servers. When you lose your connection, Gmail automatically switches to offline mode, and uses the data stored on your computer’s hard drive instead of the information sent across the network. You can read messages, star and label them, and do all of the things you’re used to doing while reading your webmail online. Any messages you send while offline will be placed in your outbox and automatically sent the next time Gmail detects a connection,”.

There will also be a “flaky connection mode” that’s supposed to give you the best of both worlds. It’ll assume that you’re disconnected and use the local cache to store your data, but whenever your connection is working, it’ll sync with Google’s servers in the background.

Last week, a team of Google engineers demonstrated a copy of Id Software’s classic first-person shooter Quake running within a browser window at a frame rate comparable to an OS-hosted copy of the game.

How did they do it? Simple. The Google Native Client is a new set of components that allows Web browsers to download and execute native x86 code. It’s not an emulator, and it’s not a virtual machine. The code runs on the actual processor with access to memory and system resources and negligible loss of performance. It even gives browser-based apps access to modern, accelerated CPU instruction sets, such as SSE.

Search engines such as Google are increasingly being used by hackers against Web applications that hold sensitive data, according to a security expert.

Even with rising awareness about data security, it takes all of a few seconds to pluck Social Security numbers from Web sites using targeted search terms.

The fact that Social Security numbers are even on the Web is a human error; the information should never be published in the first place. But hackers are using Google in more sophisticated ways to automate attacks against Web sites.

Study recently discovered a way to execute a SQL injection attack that comes from an IP (Internet Protocol) address that belongs to Google.

In a SQL injection attack, a malicious instruction is entered on a Web-based form and answered by a Web application. It often can yield sensitive information from a backend database or be used to plant malicious code on the Web page.

Tools such as Goolag and Gooscan can execute broad searches across the Web for specific vulnerabilities and return lists of Web sites that have those problems.

Another attack method is so-called Google worms, which use the search engine to find specific vulnerabilities. With the inclusion of additional code, the vulnerability can be exploited.

Google and other search engines are taking steps to stop the abuse. For example, Google has stopped certain kinds of searches that could yield a trove of Social Security numbers in a single swoop. It also puts limits on the number of search requests sent per minute, which can slow down mass searches for vulnerable Web sites.

In reality, it just forces hackers to be a bit more patient. Putting limits on search also hurts security professionals who want to do automated daily searches of their Web sites for problems.

There is another kind of attack called “site masking,” which causes a legitimate Web site to simply disappear from search results.

Google’s search engine penalizes sites that have duplicate content and will drop one from its index. Hackers can take advantage of this by creating a Web site that has a link to a competitor’s Web page but is filtered through a proxy server.

Google indexes the content under the proxy’s domain. If this is done enough times with more proxy servers, Google will consider the targeted Web page a duplicate and drop it from its index.

One way Web site administrators can defend against this is barring their Web site from being indexed by anything other than the legitimate IP address of a search engine.