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.

If you just place your both the code files in your App_Code directly this is the error you’ll see,

“The files ‘/BlogEngine.Web/App_Code/VBCode/Class1.vb’ and ‘/BlogEngine.Web/App_Code/CSCode/Extensions/BreakPost.cs’ use a different language, which is not allowed since they need to be compiled together.”

But you can get this done, here is a very simple way you can try that out,

1) First make two folders in App_code with foldernames as
- CSCode
- VBCode

2) Modify the Web.config with following code:

<compilation debug="false">
 <codeSubDirectories>
 <add directoryName="VBCode" />
 <add directoryName="CSCode" />
 </codeSubDirectories>
</compilation>

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.

select so.name, sc.name
from syscolumns sc
inner join sysobjects so on sc.id = so.id
where sc.name = 'SystemColumn'

After you download you’ll run the .exe file to extract the setup and the setup is of the .vhd format that is Virtual PC hard disk. So you’ll need Virtual PC to run Visual Studio 2010.

But, but, but guys please check out the minimum requirement for this CTP to run. Hard disk space required is 75 GB, yes, its not 7.5 but 75 GB. Well that’s not true you can have this CTP run if you have upto 25 GB on one drive.

When you extract the .exe file the .vhd file extracted is of size 23 GB.  Also when you bind the .vhd file to the virtual pc, you need minimum 1GB ram allocated to the Virtual PC disk.

When I ran the Visual Studio for the first time the screen took around 10 mins to load and I just shut down the CTP and got back to work.

The reason for the extracted file to be of 23 GB is because that VHD when you map to Virtual PC will have Visual Studio 2010, Visual Studio 2008,  SQL  Server 2008, SQL Server 2005 + many more software installed.

When you execute the Virtual PC which is mapped to VHD, Virtual PC will load Windows Server 2008 and it takes lots of  burden it killed my laptop. Although I have fair enough configuration. My processor is Core 2 Duo, 1.83 GHZ and with 1 GB ram. Yet it just killed my PC performance.

I even tried to extract the file on an External Hard Disk and Even on my IPod classic. But I was able to extract only first rar file. I googled the reason and found it was because the External Hard Disk is of FAT32 format and they do not support data transfer of more than 4GB. So I had to clean up my Hard Disk and extract 23 GB .vhd file there.

I really did not understood why Microsoft shipped Visual Studio 2010 this way. With 7GB download size and 23 GB extracted file. I was really disappointed with such strategy. Microsoft must have shipped Visual Studio 2010 as a single file. What could be the reason for adopting this process?

Here is my Virtual PC screen shot with Visual Studio 2010

If you think you’re unable to work for the best company in its sphere, make it your aim.

If you think you’re incapable of running a company, make that your aim.

If you think you’re unable to be on the cover of Time magazine, make it your business to be there.

Make your vision of where you want to be a reality.

Nothing is impossible.

In simple words, before starting anything, you must being with the end in mind – developing a clear picture of where you want to go in life and drawing up a map to get there.

Often we set goals when we are in mood, but later realise that we do not have the strength to achieve them. This is because we don’t count the cost associated with it. Here’s a simple example: Every year, you plan to get better marks in the coming exams. But before setting the goal, you need to consider what this will entail. Perhaps you will have to spend more time studying, waking up early and staying up late, watching less TV etc.

Once you’ve counted the costs, you may consider the benefits: What could good marks bring to you? A feeling of accomplishment? Entry into a good college? High self esteem? Praise?

Now ask yourself, “Am I willing to make the sacrifice?” if not, then don’t do it. Don’t make commitments you know you will break. A better way is to make the goal bite-sized. Instead of setting a goal for getting better marks in all subjects, you might want to get good marks in just two. In next semester, focus on the other two subjects.

Here is another exercise: On a sheet of paper, write down how much you would like to score in your exams. Then think about the percentage you got in your last exam, and compare that to how much you would like to score in you coming exams as well as the one after that and so on, till the final goal is reached. Now look at the your first sub goal and next to it, make two columns: In the first column, note the cost you have to bear to reach that goal. Then think about the potential benefits you may enjoy on reaching that goal. Now, truthfully answer the question, “Do I want to achieve this goal?” Write it down!

The difference between a goal and a dream is the written word. A goal not written is only a wish. A written goal carries ten times the power. We all want to achieve certain things in life and even work hard for it. But once you actually write it down in black and white, you know exactly what to do and how. Writing forces you to be specific.

Once we are fully committed to doing a task or reaching a goal, our power to reach it increases. It seems to dig up goldmines of willpower, skill and reactivity, which we didn’t even know we possessed. Of course this commitment must come with within and shouldn’t be imposed by others.

But the question, for which I am searching the answer is,
Can JQuery Tools really compete with JQuery UI? And who would answer this question better then you guys.

So what you guys think, JQuery Tools Vs JQuery UI, who wins?

I look forward for hearing your thoughts on this. As this may help others to decide what should they go from either of these