JAKARTA – Lenovo increasingly aggressive in the market by launching a series of notebook PCs and desktop All-in-One (AIO) Touch. Vendors from the Bamboo Curtain country to bring a notebook and the latest Touch AIO desktop to the consumer segment.

This new product line comes with a series of innovations to consumers in an era that claimed Lenovo PC as PC + era.

“Today is the era of PC +, no longer his time PC old. Therefore we must provide innovation in the PC industry by encouraging innovation,” said Country General Manager Lenovo Indonesia Rajesh Thadani, in the launch line of notebook and desktop AIO Touch at The Foundry, Jakarta , Tuesday (02/07/2013).

“This year we are facing challenges in the PC industry. Market PCs now it is decreasing, but we in the PC business is still going well. For the consumer segment, we are the number one PC vendor in the world,” said Rajesh.

This new product line, said Rajesh, a part of Lenovo innovations in the PC + era. The latest line of notebooks Lenovo IdeaPad Yoga is 11s, Touch IdeaPad Z400 and IdeaPad S210 Touch. As for the desktop IdeaCentre A520 AIO is Touch, Touch IdeaCentre B540, C540 and C440 Ideacentre Touch. All new products are equipped with third-generation Intel Core processor and Windows 8 operating systems.

The specifications of the latest product series include 11s IdeaPad Yoga has a 11.6-inch IPS HD screen that supports 10-point multi-touch with a side order size of 0.67 inches. Ultrabook comes in a choice of colors Silver Grey and Clementine Orange.

11s is the successor to the IdeaPad Yoga Yoga series past and is still the same as its predecessor, the convertible notebook has four modes that can be converted into a laptop, tablet, stand and tent.

IdeaPad Z400 comes with Touch screen 14-inch HD LED Backlit Display (1366 x 768) that supports 10-point multi-touch. Moreover, it also comes with extra bass and Dolby Home Theatre v4 to produce a better sound. For type carrying the IdeaPad S210 Touch HD 11.6-inch screen with Dolby Advanced Audio v2 seritifikasi, and comes with a Companion applications such as Lenovo, the Lenovo, and Lenovo Cloud.

While the IdeaCentre A520 Touch has a full HD 23-inch display with 10-point multi touch, Intel HD Graphics 4000, 4GB of DDR memory, and has additional features like Dolby Home Theater v4. IdeaCentre B540 comes with a 23-inch full HD screen that supports multi-touch 3D display and NVIDIA GeForce graphics.

While IdeaCentre C540 Touch has a 23 inch screen, and supports up to NVIDIA GeForce 615 graphics 2GB. While the C440 AIO Touch has the same features and functionality with Touch C540, but with a smaller screen that is 21.5 inches.

IdeaPad Yoga 11s, IdeaPad Z400 Touch, Touch S210 IdeaPad, IdeaCentre A520, IdeaCentre B540 Touch, Touch IdeaCentre C540 and IdeaCentre C440, has been available in the market at each price Rp10, 4 million, Rp 7, 4 million, Rp 4, 7 million , Rp12, 9 million, Rp13, 4 million, Rp 9, 9 million, and Rp 8, 4 million.

CEB TowerGroup recently named Hyland Software a Best-in-Class enterprise content management (ECM) vendor for insurance companies in three categories in its evaluation of ECM solutions providers in the space. Hyland was named Best-in-Class for: User Experience, Enterprise Operations Support and Enterprise Support.

The report identifies both current and future market drivers, identifies the needs of the industry and lists notable solutions providers. CEB TowerGroup selected vendors based on quantitative and qualitative analyses of each vendor’s solution features and functionality, understanding of customer needs and implementation of leading practices to maximize efficiency and ROI.

“Selection as a Best-in-Class solution within CEB TowerGroup’s insurance vendor review verifies the relevance and ongoing benefits ECM solutions can provide insurance companies. It illustrates Hyland’s ability to offer insurers a solution that can streamline their processes, enabling them to run more efficiently and cost-effectively across their entire organization,” stated Cheryl Nulman, Hyland’s insurance industry marketing manager.

CEB TowerGroup named Hyland Software’s OnBase a Best-in-Class solution for:

  • User Experience,  for its attributes that directly contribute to enhancing the productivity of employees across the organization
  • Enterprise Operation Support, for its attributes that support and facilitate business operations enterprise-wide
  • Enterprise Support for Hyland’s influence and ongoing relationship with customers

“Our industry expertise, coupled with the high-value we place on customers’ feedback helps to create leading solutions to meet insurers’ needs. Our agile approach increases our viability in the industry and ensures an advanced solution offering,” Nulman said.

“As insurance executives evaluate new IT products to support their business needs, many are overwhelmed by the volume of technologies available,” said Aaron Kissel, executive director, CEB. “CEB TowerGroup is the only advisory group qualified to evaluate such a broad range of insurance technology tools and to help insurers navigate the increasingly complex landscape.”

*Technology Assessment Disclaimer– CEB does not endorse any vendor, product or service depicted in our CEB TowerGroup publications and does not advise technology users to select only those vendors rated “best in class.” CEB TowerGroup research publications consist of the opinions of CEB TowerGroup’s analysts and should not be construed as statements of fact. CEB disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.

About Hyland Software

For over 20 years, Hyland Software has helped our more than 11,500 lifetime customers by providing real-world solutions to everyday business challenges. That dedication is why Hyland realizes double-digit growth, and why 98 percent of our customer base continues to renew its annual maintenance. Our customers see the ongoing value of partnering with Hyland and continue to work with us year after year.

Seamless integrations with policy administration, core administration and claims management systems speed processing times across the entire insurance lifecycle from underwriting to policy services to claims, which increases customer service. Using OnBase, insurers are able to increase profitability through accurate and consistent underwriting decisions while decreasing response times and costs associated with claims.

Mozilla Labs has outlined an experiment it’s conducting in improving the personalisation web publishers can offer readers who browse their sites using Firefox.

The outfit says it’s been working on the idea since last year, when it “conducted a series of experiments in which a user’s browsing history could be matched with interests in categories like technology, sports and cooking.”

In return for opting in to the trial, lab rats were offered “insight into how they spend time online.”

Mozilla Labs is now wondering “what if these interests were also available for the user to share with the websites they visit to get a better, more personalized browsing experience” so that “content creators and consumers could benefit from Web-based interests”?

Here’s one scenario the outfit has imagined as resulting from this line of thinking:

“For example, let’s say Firefox recognizes within the browser client, without any browsing history leaving my computer, that I’m interested in gadgets, comedy films, hockey and cooking. As I browse around the Web, I could choose when to share those interests with specific websites for a personalized experience. Those websites could then prioritize articles on the latest gadgets and make hockey scores more visible.”

Some publishers have already pressed the API for this kind of thing into service, according to the Mozilla Blog, but the code is not in the wild and is being tested – technically and conceptually – as Mozilla figures out how people will react to websites that dynamically change content based on readers’ past behaviours.

One example of successful personalisation mentioned in the posts announcing the initiative is The Guardian’s offer to ensure its readers see no news about the birth of George Alexander Louis Windsor. That’s a service many will doubtless enjoy. Whether such personalisation can result in readers choosing only to encounter lines of inquiry and opinions they already agree with, and therefore deciding to consume media that re-enforces their feelings rather than offering broader perspectives, is a wider debate for another day. Or the comments.

Jakarta – In June 2013, Sony has introduced smart watches, Sony SmartWatch 2. Previous smart watches is reported to be released on July 15, 2013. But, then again Sony deliver a new launch date for the SmartWatch 2 on 9 September 2013.
If ordered through Clove website, you can get 2 SmartWatch soon after launch. This smart watches IP57 certified. So SmartWatch 2 can be brought into the water up to a depth of 1 meter for 30 minutes. In addition, the SmartWatch 2 also anti dust.
Sony SmartWatch 2 had 200 applications. The developers can also access the API (Application Programming Interface) to add the application. This device is compatible with all types of operating system Android 4.0 and above. This watch is also equipped with NFC technology (Near Field Communication).
With smart watches SmartWatch, the user can answer or ignore the call. SmartWatch 2 also displays incoming phone call notifications and missed calls. Wearable device also has a calendar and weather applications and other applications that can be downloaded on Google Play Store. Sony Smartwatch 2 will be priced at U.S. $ 181 or about USD 1.8 million.
Besides Sony, other technology manufacturers like Apple, Microsoft, Google and others are now also working on smart watches. It is estimated that smart watches will emerge from 2014. Wearable devices or devices that can be used are likely to soon become a new trend in the technology market.

Approaching the Upper Class

Asus GTX660 graphics card-DC2T-2GD5 comes with a specification that is faster than the reference. Asus set a speed accelerator graphics card Nvidia GK106 based graphics core is at 1072MHz. Speed ​​is higher than the reference GeForce GTX 660 has a 980MHz speed accelerator. Not only that, the speed of the accelerator can still u7-435-1137MHz Asusmeningkat longer automatically when needed. In addition, the speed of local memory is also pegged slightly higher, at 3050MHz (6100MHz effective) than the reference 3000MHz (6000 MHz effective). Unfortunately, while trying to overclock, he refused. It seems, the default value used is the maximum value.

In terms of design, graphics card with 960 CUDA cores and 2GB of memory GDDR5 192bit local has a design that resembles the Asus graphics cards in general. Him, Asus DirectCU cooler pair which is typical Asus cooler. Overall the Asus GTX660-DC2T-2GD5 have a pretty long card size. Therefore, make sure your case has enough space. DirectCU cooling that is used is quite stocky with two large fans and also comes with a copper heatpipe to help remove heat. However, this is quite slim DirectCU cooling that makes the graphics card is not too thick. Asus device is “only” requires two slots in your chassis

Oh yes, the GeForce GTX 660 graphics card is theoretically requires about 140W, therefore, at the end there is a power port PCI-Express 6pin to meet its needs. Also make sure you use a power supply that has enough power.

Regarding the output options, Asus GTX660-DC2T-2GD5 provides output options that are complete: two DVI, one HDMI, and one DisplayPort. For those of you who want to use dual graphics card configuration, it also supports SLI.

About its performance, the Asus graphics card performance is quite good for the middle class. Its performance is very adequate for running a variety of the latest 3D games at high resolution with high detail anyway. In fact, its performance can approach the graphics card that was in it, such as the AMD Radeon HD 7870 and Radeon HD 7950. DirectCU cooling that uses the performance was quite good for being able to keep the temperature remained normal without producing noise.

Asus GTX660-DC2T-2GD5 is a middle class graphics card that can deliver performance-class graphics card like a top. The price is quite high, but it is balanced with a price performance that is able to produce.

CoffeeScript, as many people know, is a transpile-to-JavaScript language.1 For the most part, it does not introduce major changes in semantics. For example, this:

-> 'Hello, world'

Transpiles directly to:

function () { return 'Hello, world'; }

This is convenient syntactic sugar, and by removing what some folks call the “syntactic vinegar” of extraneous symbols, it encourages the use of constructs that would otherwise make the code noisy and obscure the important meaning. The vast majority of features introduced by CoffeeScript are of this nature: They introduce local changes that transpile directly to JavaScript.2

CoffeeScript also introduces features that don’t exist in JavaScript, such as destructuring assignment and comprehensions. In each case, the features compile directly to JavaScript without introducing changes elsewhere in the program. And since they don’t look like existing JavaScript features, little confusion is created.

equals doesn’t equal equals

One CoffeeScript feature does introduce confusion, and the more you know JavaScript the more confusion it introduces. This is the behaviour of the assignment operator, the lowly (and prevalent!) equals sign:

foo = 'bar'

Although it looks almost identical to assignment in JavaScript:

foo = 'bar';

It has different semantics. That’s confusing. Oh wait, it’s worse than that: Sometimes it has different semantics. Sometimes it doesn’t.

So what’s the deal with that?

Well, let’s review the wonderful world of JavaScript. We’ll pretend we’re in a browser application, and we write:

foo = 'bar';

What does this mean? Well, it depends: If this is in the top level of a file, and not inside of a function, then foo is a global variable. In JavaScript, global means global across all files, so you are now writing code that is coupled with every other file in your application or any vendored code you are loading.

But what if it’s inside a function?

function fiddleSticks (bar) {
  foo = bar;
  // ...
}

For another example, many people enclose file code in an Immediately Invoked Function Expression (“IIFE”) like this:

;(function () {
  foo = 'bar'
  // more code...
})();

What do foo = 'bar'; or foo = bar; mean in these cases? Well, it depends as we say. It depends on whether foo is declared somewhere else in the same scope. For example:

function fiddleSticks (bar) {
  var foo;
  foo = bar;
  // ...
}

Or:

function fiddleSticks (bar) {
  foo = bar;
  // ...
  var foo = batzIndaBelfrie;
  // ...
} 

Or even:

function fiddleSticks (bar) {
  foo = bar;
  // ...
  function foo () {
    // ...
  }
  // ...
}

Because of something called hoisting,3 these all mean the same this: foo is local to function fiddleSticks, and therefore it is NOT global and ISN’T magically coupled to every other file loaded whether written by yourself or someone else.

nested scope

JavaScript permits scope nesting. If you write this:

function foo () {
  var bar = 1;
  var bar = 2;
  return bar;
}

Then bar will be 2. Declaring bar twice makes no difference, since both declarations are in the same scope. However, if you nest functions, you can nest scopes:

function foo () {
  var bar = 1;
  function foofoo () {
    var bar = 2;
  }
  return bar;
}

Now function foo will return 1 because the second declaration of bar is inside a nested function, and therefore inside a nested scope, and therefore it’s a completely different variable that happens to share the same name. This is called shadowing: The variablebar inside foofoo shadows the variable bar inside foo.

javascript failure modes

Now over time people have discovered that global variables are generally a very bad idea, and accidental global variables doubly so. Here’s an example of why:

function row (numberOfCells) {
  var str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

function table (numberOfRows, numberOfColumns) {
  var str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';
}

Let’s try it:

table(3, 3)
  //=> "<table><tr><td></td><td></td><td></td></tr></table>"

We only get one row, because the variable i in the function row is global, and so is the variable i in the function table, so they’re the exact same global variable. Therefore, after counting out three columns, i is 3 and the for loop in table finishes. Oops!

And this is especially bad because the two functions could be anywhere in the code. If you accidentally use a global variable and call a function elsewhere that accidentally uses the same global variable, pfft, you have a bug. This is nasty because there’s this weird action-at-a-distance where a bug in one file reaches out and breaks some code in another file.

Now, this isn’t a bug in JavaScript the language, just a feature that permits the creation of very nasty bugs. So I call it a failure mode, not a language bug.

coffeescript to the rescue

CoffeeScript addresses this failure mode in two ways. First, all variables are local to functions. If you wish to do something in the global environment, you must do it explicitly. So in JavaScript:

UserModel = Backbone.Model.extend({ ... });
var user = new UserModel(...);

While in CoffeeScript:

window.UserModel = window.Backbone.Model.extend({ ... })
user = new window.UserModel(...)

Likewise, CoffeeScript bakes the IIFE enclosing every file in by default. So instead of:

;(function () {
  // ...
})();

You can just write your code.4

The net result is that it is almost impossible to replicate the JavaScript failure mode of creating or clobbering a global variable by accident. That is a benefit.

what would coffeescript do?

This sounds great, but CoffeeScript can be surprising to JavaScript programmers. Let’s revisit our table function. First, we’ll fix it:

function row (numberOfCells) {
  var i,
      str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

function table (numberOfRows, numberOfColumns) {
  var i,
      str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';
}

table(3, 3)
  //=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

Good! Now suppose we notice that no function calls row other than table. Although there is a slightly more “performant” way to do this, we decide that the clearest and simplest way to indicate this relationship is to nest row inside table Pascal-style:

function table (numberOfRows, numberOfColumns) {
  var i,
      str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';

  function row (numberOfCells) {
    var i,
        str = '';
    for (i = 0; i < numberOfCells; ++i) {
      str = str + '<td></td>';
    }
    return '<tr>' + str + '</tr>';
  }
}

It still works like a charm, because the i in row shadows the i in table, so there’s no conflict. Okay. Now how does it work in CoffeeScript?

Here’s one possible translation to CoffeeScript:

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

It works just fine. Here’s another:

table = (numberOfRows, numberOfColumns) ->
  str = ""
  i = 0
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr></table>"

Broken! And a third:

str = ""
i = 0
table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr></table>"

Also broken! Although the three examples look similar, the first gives us what we expect but the second and third do not. What gives?

Well, CoffeeScript doesn’t allow us to “declare” that variables are local with var. They’re always local. But local to what? In CoffeeScript, they’re local to the function that either declares the variable as a parameter or that contains the first assignment to the variable.5 So in our first example, reading from the top, the first use of str and i is inside the row function, so CoffeeScript makes them local to row.

A little later on, the code makes an assignment to i and str within the table function. This scope happens to enclose row’s scope, but it is different so it can’t share the strand i variables. CoffeeScript thus makes the i and str in table variables local totable. As a result, the i and str in row end up shadowing the i and str in table.

The second example is different. The first i encountered by CoffeeScript is in table, so CoffeeScript makes it local to table as we’d expect. The second i is local to row. But since row in enclosed by table, it’s possible to make that i refer to the i already defined, and thus CoffeeScript does not shadow the variable. The i inside row is the same variable as the i inside table.

In the third example, i (and str) are declared outside of both table and row, and thus again they all end up being the same variable with no shadowing.

Now, CoffeeScript could scan an entire function before deciding what variables belong where, but it doesn’t. That simplifies things, because you don’t have to worry about a variable being declared later that affects your code. Everything you need to understand is in the same file and above your code.

In many cases, it also allows you to manipulate whether a variable is shadowed or not by carefully controlling the order of assignments. That’s good, right?

all those against the bill, say “nay nay!”

Detractors of this behaviour say this is not good. When JavaScript is written using var, the meaning of a function is not changed by what is written elsewhere in the file before the code in question. Although you can use this feature to control shadowing by deliberately ordering your code to get the desired result, a simple refactoring can break what you’ve already written.

For example, if you write:

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

All will be well, until you are debugging late one night, and you add:

console.log('Hello!') for i in [1..5]

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "table><tr><td></td><td></td><td></td></tr></table>"

This breaks your code because the i you used at the top “captures” the other variables so they are now all the same thing. To someone used to JavaScript, this is a Very Bad Thing™. When you write this in JavaScript:

function row (numberOfCells) {
  var i,
      str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

It will always mean the same thing no matter where it is in a file, and no matter what comes before it or after it. There is no spooky “action-at-a-distance” where code somewhere else changes what this code means. Whereas in CoffeeScript, you don’t know whether the iin row is local to row or not without scanning the code that comes before it in the same or enclosing scopes.

coffeescript’s failure mode

In this case, CoffeeScript has a failure mode: The meaning of a function seems to be changed by altering its position within a file or (in what amounts to the same thing) by altering code that appears before it in a file in the same or enclosing scopes. In contrast, JavaScript’s var declaration never exhibits this failure mode. JavaScript has a different action-at-a-distance failure mode, where neglecting var causes action at a much further distance: The meaning of code can be affected by code written in an entirely different file.

Mind you, the result of calling our row function is not affected by declaring an i in an enclosing scope. Our function always did what it was expected to do and always will. Although you and I know why the change breaks the table function is that row now uses an enclosed variable, imagine that we were writing unit tests. All of our tests for row would continue to pass, it’s the tests for table that break. So in an evidence-based programming sense, when we maintain the habit of always initializing variables we expect to use locally, changing code outside of those functions only changes the evidence that the enclosing code produces.

So one way to look at this is that row is fine, but moving i around changes the meaning of the code where you move i. And why wouldn’t you expect making changes to tableto change its meaning?

so which way to the asylum?

If you ask around, you can find people who dislike JavaScript’s behaviour, and others who dislike CoffeeScript’s behaviour. Accidentally getting global variables when you neglectvar is brutal, and action-at-a-distance affecting the meaning of a function (even if it is always within the same file) flies against everything we have learned about the importance of writing small chunks of code that completely encapsulate their behaviour.

Of course, programmers tend to internalize the languages they learn to use. If you write a lot of JavaScript, you habitually use var and may have tools that slap your wrist when you don’t. You’re bewildered by all this talk of action-at-a-distance. It will seems to you to be one of those rookie mistake problems that quickly goes away and is not a practical concern.

Likewise, if you write twenty thousand lines of CoffeeScript, you may never be bitten by its first-use-is-a-declaration behaviour. You may be in the habit of using variable names likeiRow and iColumn out of habit. You may find that your files never get so large and your functions so deeply nested that a “capture” problem takes longer than three seconds to diagnose and fix.

It’s a bit of a cop-out, but I suggest that this issue resembles the debate over strong, manifest typing vs. dynamic typing. In theory, one is vastly preferable to the other. But in practice, large stable codebases are written with both kinds of languages, and programmers seem to adjust to overcome the failure modes of their tools unconsciously while harvesting the benefits that each language provides.


  1. Yes, “transpile” is a real word, or at least, a real piece of jargon. It’s a contraction of “transcompiler,” which is a compiler that translates one language to another language at a similar level of abstraction. There’s room for debate over what constitutes a “similar level of abstraction.” https://en.wikipedia.org/wiki/Source-to-source_compiler

  2. There are other possibilities: You could write a Tail-Call Optimized language that transpiles to JavaScript, however its changes wouldn’t always be local: Some function calls would be rewritten substantially to use trampolining. Or adding continuations to a language might cause everything to be rewritten in continuation-passing style.

  3. Scanning all of the code first is called “hoisting,” in part because some declarations nested in blocks are “hoisted” up to the level of the function, and all declarations are “hoisted” to the top of the function. This is a source of confusion for some programmers, but it isn’t germane to this essay.

  4. If you don’t want the file enclosed in an IIFE, you can compile your CoffeeScript with the--bare command-line switch.

The world’s largest search engine company, Google will soon be officially shut down one of his services. The services that will be closed is Google Latitude which is a location sharing application.

Closure is made after a company based in Mountain View did a massive change on Google Maps. In addition, this application also has a very low popularity. Google Latitude consumption levels far below other applications such as Foursquare or Facebook. Not only that, Latitude also less popular than the location-sharing service owned by Google.

Google Latitude itself is a location sharing application that is integrated with Google Maps. This feature allows for automatic location tracking, check in at a place it can also be set automatically or manually.

In the latest update Google Maps on Android, this feature is not found anymore. Selian it, Google also removed the existence of Google Latitude app available on iOS and has officially retire the Latitude API. So third-party applications that use these APIs will not work, unless using a sharing site owned by Google.

Did you pour your heart out on a MySpace blog and make hourly checks on your Friends total? Now the social network has been accused of erasing the personal histories of its dedicated members after a $20 million relaunch designed to bury its past and attract a new teenage audience.

The music-centred platform, which helped launch Lily Allen to fame and attracted 100 million users at its 2007 peak, is seeking to climb out of the social network “graveyard” after years of being a source of digital derision.

The site, lacking innovation and overtaken by Facebook, shed users and was abandoned by Rupert Murdoch, whose News Corporation had bought the company in a disastrous $580 million deal.

Backed by new investors, including singer Justin Timberlake, Myspace (after dropping the capital ‘S’) has been rebranded as a music-streaming service, with a new sleek interface, and an iPhone app for radio play and animated GIF creation.

The new Myspace has shown signs of life, attracting 31 million unique visitors and one million app downloads since a high-profile relaunch last month.

However its owners do not appear to want those loyal users, who stuck around even when MySpace became a tarnished brand, to spoil the party for its new target audience of young “millenials”.

Furious users complained that Myspace has erased all of their blogs, private messages, videos, comments and posts, when they try and log-in to the new site.

Myspace veterans, whose lives have been marked out by the blogs and photos posted daily over nearly a decade, are threatening a class-action lawsuit over what they see as the destruction of their personal histories.

One disgruntled member wrote: “I was a loyal user who never deserted Myspace. I used it almost everyday since 2006. I wrote hundreds of blogs that, to my horror, were simply gone as of last night with no prior warning given. That is no way to treat us. Please give us a chance to recover old blogs. This is like losing family photographs, and it is really horrible.”

Another posted on the site’s forum: “This is no different than losing one’s writing or photographs in a house fire, and I am feeling awful right now.” “You in essence just stole our blogs without permission to delete them. How dare you!,” complained another user.

Myspace, bought for just $35 million in 2011 by Timberlake and the Specific Media Group, told users that it had made changes to create a “better experience.” The company said: “That means you won’t see a few products on the new site. We know that this is upsetting to some but it gives us a chance to really concentrate on creating a new experience for discovery and expression.”

The “year zero” approach extends to stars who once built huge followings through MySpace. Britney Spears, who enjoyed 1.5 million Friends on the old MySpace, found her new “Connections” count set to 0.

Myspace won’t mind irritating 30-somethings who enjoyed sharing family photos if the network maintains a positive buzz from younger users since the relaunch, which featured the rapper Pharrell in a major advertising campaign.

The new app is ranked among the Top 20 social networking apps and the site makeover received positive feedback on Twitter.

Yet Myspace has been forced to respond to the backlash from its loyal users.  “Change isn’t easy and there has been a lot going on lately,” the company said. It told angry members: “We understand that this (blog) information is very important to you. Please understand that your blogs have not been deleted. Your content is safe and we have been discussing the best ways possible to provide you your blogs.” Pictures and music playlists can be located and transferred over to the new Myspace, the company added.

Founded in 2003 by a team of California web pioneers led by Tom Anderson and Chris DeWolfe, MySpace generated $800 million in revenue by 2008. Arctic Monkeys were among the bands who used the network’s music-sharing feature as a springboard for success.

Whether you’re a tinkerer with a custom rig, or you just aren’t sure why your computer’s fans are running, checking your CPU usage is a pretty common task. Instead of using a boring on-screen activity monitor though, you can hook up your machine to a car tachometer for constant feedback.

This hack comes courtesy of ivancreations, who created an entire PC monitoring block from real-world components. The full instructions are on his blog and needless to say, they’re pretty complicated. If you can makes heads and tails of his plans though, the results speak for themselves.

While the tachometer is my favourite part of the build, he also wired up some LED light grids to illustrate other vital system information as well. If you think you’re up to it, or just want a closer look, be sure to check out the source link.

MediaTek has just introduced its newest processor Octa Core MT6592. And as same-same company based in China, Huawei did not want to miss. An anonymous source who claimed close to Huawei Huawei revealed that the party has completed the development of the Octa core processors.

The source said that the latest generation K3V3 processor has the ability to run in high temperatures as well as cooling the components inside. By doing so, this processor also increases the standby time of the device.

Previously, CEO of Huawei, Richard Yu said that they will soon introduce the latest K3V3 Octa core processors in the second half of 2013.

Yu said that the processor will have a speed of 1.8GHz and a Mali GPU with 28nm technology in the manufacturing process. This processor is also a processor based on the ARM Cortex A15 architecture.