Panasonic Lumix DMC-XS3, Latest Digital Camera with 14.1MP MOS sensor has a high sensitivity

Panasonic not only introduced the new Lumix cameras that rely on high zoom capability. The Japanese company also helped bring a compact camera Lumix DMC-XS3 that rely 14.1 MP MOS sensor with high sensitivity.

This digital camera is designed with a slim shape and body size of 14 millimeters. Although the size is quite small, this camera is claimed to deliver high quality images thanks to sensors that can reduce noise. In addition, this camera also features a 5x optical zoom and 10x zoom intelegent.

Panasonic Lumix DMC-XS3 also has the ability to record full HD video in MP4 format. In it there is also a feature called Intelligent Auto (iA) which enables features like Intelligent ISO Control, Intelligent Scene Selector, Face Detection and Intelligent Exposure is done automatically.

For shooting in low-light atmosphere, there is a Handheld Night Shot mode. This mode can produce high quality images with a single shot.

Present Mozilla Firefox Beta 23

Jakarta (ANTARA News) – Following the release of Firefox 22 two days ago, Mozilla announced the Firefox Beta update, with version 23, on the desktop and Android.

As reported by TheNextWeb, Wednesday, Firefox Beta 23 is available for Windows, Mac, and Linux. The biggest addition is the function of sharing new Mozilla.

Firefox beta has a new Share button and the panel for the application programming interfaces (Application Program Interface / API) social. In other words, developers can let users share content with friends with one click (Facebook users, for instance, can use it to share content directly from Firefox).

In addition, Firefox Social API now open to all developers who are interested in integrating their services to the website or the Mozilla browser.

This feature was first comes back in Firefox 17 in November 2012, is integrated with Facebook in December 2012, and then expanded to support providers with Firefox 21 in May this year.

In short, social API lets you keep up with the latest social events without having to switch to a new tab. Mozilla developed the “activation of social services and providers that integrate directly into Firefox where users can search for content or websites in person”. So now any developer can participate.

Next up is a mixture of content blocker, prevents (HTTP) malicious content on the site is being read or modified by an attacker with blocking. Content mixture occurs when a web page containing a combination of content secure (HTTPS) and non-secure (HTTP) which is transmitted through a secure data channel to the browser.

Finally, developers can use the new network monitor. Monitor new tissue damage components of individual sites, highlighting how long it takes each of the sites to load.

Yahoo Officially Startup Acquisitions of Chinese origin Ztelic

Yahoo is now led by Marissa Mayer has not quit to continue to develop the company. Several acquisitions were they doing. And now turn to a Chinese origin named Ztelic startup recently purchased by Yahoo.

Neither Yahoo nor Ztelic parties did not disclose to the public how much nominal money involved in the transaction. However, information on the step acquisition was officially inscribed in Ztelic site on Thursday (07/18/2013) local time.

In a statement, Ztelic say that they are very pleased to be joining the company at Yahoo. This acquisition was a step they refer to as a step forward and could give a positive value for the company. Especially at this time Yahoo has 700 million users.

Ztelic itself is a startup that develops software for analyzing and monitoring activity on social networks. This step was carried out Yahoo acquisition to increase investment in R & D. Interestingly, the founder of Ztelic Hao Zheng is one of the former R & D laboratory personnel Yahoo China and had developed a game for Zynga.

It’s a Mad, Mad, Mad, Mad World: Scoping in CoffeeScript and JavaScript

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.

Adobe’s Kuler beta site resurrects photo-color picker

Adobe Systems has launched a beta version to try out changes to its color-picker Kuler service, including the restoration of an earlier feature to extract dominant colors from photos.

Kuler lets people assemble quintets of colors into a color scheme that’s saved into their own archive; people can browse others’ schemes as well. The colors can be imported into Adobe’s Illustrator software, too.

The photo tool is available by loading the new Kuler beta site. Adobe said Monday it’s seeking feedback on the changes, which it may or may not keep. Adobe also provided an option to use a less obtrusive color wheel and to shrink borders around colors so designers can better judge how they look together.

Kuler is useful, though hardly a heavyweight app like Photoshop or After Effects. But it’s interesting to watch since it’s got new-era online, collaborative, and social aspects that seem to be a priority for Adobe as it tries to convince skeptics that its $50-per-month Creative Cloud subscription is more than just a new way to pay for the old Creative Suitesoftware.

When Adobe cut over to its Creative Cloud subscription program, it introduced an iOS app that also can pick a color scheme from a photo.

Adobe once had a Kuler app for Android, but scrapped it and is channeling its resources toward the Kuler Web interface at present.

In response to a request for a Kuler Android app, an Adobe staff member had this to say:

While the iOS app and the discontinued Android app do have similar capabilities, they are actually quite a bit different. We have found that people use tablets and mobile phones very differently. So, we created the iPhone app with a different focus in mind — which translated to different features, UI, and interactions.

We have also found the tasks most people wanted to accomplish with Kuler, on a tablet device, are very similar to the tasks people undertake with the Kuler website. So, we’ve invested a lot of time and effort into updating the site to embrace the latest Web standards (also announced at MAX). And, it should work really well on Android and iOS tablets. We look forward to getting these updates in the hands of users to hear what they think.

We understand there are many Android phone users who may find an app like the Kuler iPhone app useful, and we’ll monitor demand for that over time.

In my tests on a Nexus 7 tablet, I was able to use the normal Kuler site, but the photo upload and color-wheel shrinking features had some problems. I could use photos I took on the spot and from the photo gallery, but imports from Google+ galleries, Dropbox, and Google Drive failed. Worse, the color wheel for picking colors by hand didn’t work with my touch screen.

Parallel and Concurrent Programming in Haskell

As one of the developers of the Glasgow Haskell Compiler (GHC) for almost 15 years, I have seen Haskell grow from a niche research language into a rich and thriving ecosystem. I spent a lot of that time working on GHC’s support for parallelism and concurrency. One of the first things I did to GHC in 1997 was to rewrite its runtime system, and a key decision we made at that time was to build concurrency right into the core of the system rather than making it an optional extra or an add-on library. I like to think this decision was founded upon shrewd foresight, but in reality it had as much to do with the fact that we found a way to reduce the overhead of concurrency to near zero (previously it had been on the order of 2%; we’ve always been performance-obsessed). Nevertheless, having concurrency be non-optional meant that it was always a first-class part of the implementation, and I’m sure that this decision was instrumental in bringing about GHC’s solid and lightning-fast concurrency support.

Haskell has a long tradition of being associated with parallelism. To name just a few of the projects, there was the pH variant of Haskell derived from the Id language, which was designed for parallelism, the GUM system for running parallel Haskell programs on multiple machines in a cluster, and the GRiP system: a complete computer architecture designed for running parallel functional programs. All of these happened well before the current multicore revolution, and the problem was that this was the time when Moore’s law was still giving us ever-faster computers. Parallelism was difficult to achieve, and didn’t seem worth the effort when ordinary computers were getting exponentially faster.

Around 2004, we decided to build a parallel implementation of the GHC runtime system for running on shared memory multiprocessors, something that had not been done before. This was just before the multicore revolution. Multiprocessor machines were fairly common, but multicores were still around the corner. Again, I’d like to think the decision to tackle parallelism at this point was enlightened foresight, but it had more to do with the fact that building a shared-memory parallel implementation was an interesting research problem and sounded like fun. Haskell’s purity was essential—it meant that we could avoid some of the overheads of locking in the runtime system and garbage collector, which in turn meant that we could reduce the overhead of using parallelism to a low-single-digit percentage. Nevertheless, it took more research, a rewrite of the scheduler, and a new parallel garbage collector before the implementation was really usable and able to speed up a wide range of programs. The paper I presented at the International Conference on Functional Programming (ICFP) in 2009 marked the turning point from an interesting prototype into a usable tool.

All of this research and implementation was great fun, but good-quality resources for teaching programmers how to use parallelism and concurrency in Haskell were conspicuously absent. Over the last couple of years, I was fortunate to have had the opportunity to teach two summer school courses on parallel and concurrent programming in Haskell: one at the Central European Functional Programming (CEFP) 2011 summer school in Budapest, and the other the CEA/EDF/INRIA 2012 Summer School at Cadarache in the south of France. In preparing the materials for these courses, I had an excuse to write some in-depth tutorial matter for the first time, and to start collecting good illustrative examples. After the 2012 summer school I had about 100 pages of tutorial, and thanks to prodding from one or two people (see the Acknowledgments), I decided to turn it into a book. At the time, I thought I was about 50% done, but in fact it was probably closer to 25%. There’s a lot to say! I hope you enjoy the results.

Audience

You will need a working knowledge of Haskell, which is not covered in this book. For that, a good place to start is an introductory book such as Real World Haskell (O’Reilly), Programming in Haskell (Cambridge University Press), Learn You a Haskell for Great Good! (No Starch Press), or Haskell: The Craft of Functional Programming (Addison-Wesley).

How to Read This Book

The main goal of the book is to get you programming competently with Parallel and Concurrent Haskell. However, as you probably know by now, learning about programming is not something you can do by reading a book alone. This is why the book is deliberately practical: There are lots of examples that you can run, play with, and extend. Some of the chapters have suggestions for exercises you can try out to get familiar with the topics covered in that chapter, and I strongly recommend that you either try a few of these, or code up some of your own ideas.

As we explore the topics in the book, I won’t shy away from pointing out pitfalls and parts of the system that aren’t perfect. Haskell has been evolving for over 20 years but is moving faster today than at any point in the past. So we’ll encounter inconsistencies and parts that are less polished than others. Some of the topics covered by the book are very recent developments: Chapters 4, 5, 6, and pass:[14 cover frameworks that were developed in the last few years.

The book consists of two mostly independent parts: Part I and Part II. You should feel free to start with either part, or to flip between them (i.e., read them concurrently!). There is only one dependency between the two parts: Chapter 13 will make more sense if you have read Part I first, and in particular before reading “The ParIO monad”, you should have read Chapter 4.

While the two parts are mostly independent from each other, the chapters should be read sequentially within each part. This isn’t a reference book; it contains running examples and themes that are developed across multiple chapters.

Asphalt 8: Airborne Optimized for Tablet Nexus 7 Newest

The latest series flagship racing game Gameloft, Asphalt 8: Airbourne will present shortly, has been optimized with OpenGL ES 3.0 for the latest tablet Nexus 7. As exhibited at Google Keynote event yesterday in San Francisco.
Baudoin Corman as Vice President of Gameloft Publishing Section Regional Americans say, 8 Asphalt is an ideal game to demonstrate the greatness of Google’s latest device, the graphics are awesome and convenient physical form, the Nexus 7 will certainly help boost the popularity of gaming on tablets and realize the vision of Asphalt 8.
In addition to the new engine, Asphalt 8 will also bring 180 events, 47 official cars, and new game modes. There is also an online multiplayer mode with global leaderboard and social features like Facebook. Gamloft is arguably the first game publisher in the gaming service that supports Google Play. Asphalt 8 itself will be the first Gameloft game titles integrated Google services and Google Play at launch.

Thanko Quad-core Android SmartTV 2, PC Portable LCD TV to Change Android Devices Being Great

Want to feel the sensation of the Android experience to a jolly? If so, the latest portable PCs known as Thanko Quad-core Android SmartTV 2 this might be an alternative solution.

With features and capabilities that it has, you can use Android SmartTV Thanko Quad-core 2 is to convert non-Adroid devices such as LCD TV into an Android device.

PC portable measuring 122x175x121mm and weighs 250g is complemented by a 1.6GHz Quad Core CPU, operating system Android 4.2 Jelly Bean, and a built-in 2GB memory. And thanks to the existence of two existing USB terminal, you can use it with a keyboard, mouse, portable HDD and so on.

While about prices in Japan itself, Thanko Quad-core Android SmartTV 2 priced around ¥ 14,800 or the equivalent of 1.5 million dollars per unit.

Try Browser, Can Direct Voucher Rp 50,000!

Although less popular among netizens, the browser application (browser) Internet Explorer apparently still prevail as the most widely used browser.

Based on the results of research from Net Applications, between December 2012 and January 2013, the number of Internet Explorer users scored 55.14 percent in January.

While Firefox and Google Chrome remained in a two and three, which stood at 19.94 per cent and 17.48 per cent.

In detail, IE10 get 1.29 percent of the market, while IE9 was 20.93 percent and IE 8 is still the best value for Microsoft with 23.54 percent.

Although the youngest position, IE10 recently earned the most secure browser (Read: Adu Safe, IE10 Defeat Firefox and Chrome).

However, it is not know it was love? Therefore, Microsoft Indonesia Kompas.com invites readers to try out the most secure browser.

Not only could give it a try, you will also receive a voucher directly from the online shopping site Lazada of Rp 50,000 (these terms and conditions) as soon as you download this browser.

How easy really. You live register and download IE10 on the following link, and also provide a unique commentary. The three most interesting comments will get a voucher worth Rp 200,000.

Asus launches Windows 8-based Transformer Book TX300 at Rs 91,999

New Delhi: Asus announced the launch of the Transformer Book TX300 in India at Rs 91,999. The company claims it to be the world’s thinnest Window 8 tablet and detachable notebook.

The Asus Transformer Book is a 13.3-inch notebook with a detachable tablet which has a Full HD IPS touch panel and a 178 degree viewing angle. It comes with an Intel Core i5 processor. The Asus Transformer Book is available with Windows 8 Professional.

It can either be used as a Windows 8 multi-touch tablet or a notebook with keyboard and touchpad. It comes with two types of internal storage device. “As a tablet, the 128GB SSD means apps launch instantly for a slick and seamless Windows 8 experience, while ASUS WebStorage ensures easy access to secure cloud storage when travelling far and wide. Connect Asus Transformer Book to its notebook dock and it instantly becomes a fully functional notebook with up to a 500GB hard drive,” said the company.

In Notebook Mode, the Asus Transformer Book features a backlit keyboard with ambient light control that automatically adjusts its brightness to suit the surroundings. it has up to five hours of battery life in full notebook mode and up to eight hours in tablet mode. It has a front 720p HD and a rear 5-megapixel camera.

The Asus Transformer Book will be available in India across select Asus authorised retail outlets starting second week of July 2013.