Monthly Archives: December 2016

Logitech Z600, Speaker Bluetooth To Work Desk

Neat work desk often improve the mood to work and be creative. Workbench clutter usually found in the form of an intricate and difficult cable neatly.
Logitech Z600 Logitech Z600 Bluetooth 1, Bluetooth Speaker For Job news desk computer computer accessories computer
Logitech Z600, Speaker Bluetooth To Work Desk
With the Logitech Z600, at least one of the two wires that disappear at your desk. Armed with a Bluetooth connection, stereo speakers can be connected to a laptop, desktop PCs, tablets, and smartphones. You can connect to three devices at once. Clever, these speakers can also be used in devices with the old Bluetooth profiles that do not support audio streaming.
Logitech Z600 Logitech Z600 3 bluetooth, Bluetooth Speaker For Job news desk computer computer accessories computer
Logitech Z600, Speaker Bluetooth To Work Desk
Z600 has been equipped with three drivers in each unit. At the top of the right speaker, available touch panel to adjust the volume. You just swiping a finger to increase or slow down the sound. Also available is a 3.5 mm audio jack for connecting non-Bluetooth devices such as the iPod nano or iPod Shuffle.
Logitech Z600 Logitech Z600 Bluetooth 4, Bluetooth Speaker For Job news desk computer computer accessories computer
Logitech Z600, Speaker Bluetooth To Work Desk
Logitech Bluetooth Speakers Z600 will be available in the UK and the United States began in August. The price is estimated at Rp 1.8 million. Currently no information when these speakers will be present in Indonesia.

HP Series 800 G1 Generate EliteOne Sharp graphics

JAKARTA – HP EliteOne 800 Series G1 and Series 800 G1 is a device EliteDesk AiO HP commercial desktop PCs and most resilient form factor with the widest selection, which was created specifically to meet the demands of today’s business.
HP desktop series EliteDesk / EliteOne 800 G1 is supported by the 4th generation Intel ® Core ™ processors for maximum performance and the graphics are sharp, and the new caching option and a solid state drive that provides fast access to data and applications.
AiO devices and desktop PCs supported by HP Elite features enterprise-class security and client management solutions to protect and manage critical business data, device and user identity with Intel vPro support.
With the highest efficiency class power supply that is up to 94 percent, Total Cost of Ownership (TCO) offered by this device was not in doubt.
EliteOne HP AiO PC 800 G1 is the most powerful, rich multimedia, with a stylish design which is 23 percent thinner than the previous generation and support for Windows ® 8 with a dynamic touch screen experience, and highly interactive interface.
HP EliteDesk / 800 series G1 EliteOne provide robust and reliable performance with deployment options that can be tailored to the needs of the organization, all backed by a comprehensive portfolio management and security solutions from HP. (Eko Sutriyanto)

Acer Launches Aspire Z3 AiO PC-605 with 23 inch Full HD Screen

Taiwanese electronics company, Acer has just introduced its PC all-in-one new, the Acer Aspire Z3-605. AiO PC this one was relying on a large screen and has a high resolution.

Acer Aspire Z3-605 has a 23-inch touch screen with full HD 1080p resolution. AiO PC offers an Intel Core i3-3227U to support 1TB HDD and 4GB of RAM. In addition, Acer is also preparing AiO PC with Intel Core i5 processor options and 8GB of RAM.

AiO PC was launched with the Windows 8 operating system. This computer also comes with an HDMI port and audio output using the optimized Dolby Home Theater v4 technology. AiO PC is also noted as the first with Harman Kardon speakers. In addition, the computer can also be tilted to the position of 10 to 30 degrees.

Regarding the price, this AiO PCs sold at prices ranging from 699.99 USD or about 7 million dollars.

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.

Yahoo Sports Launches New Fantasy App With Mobile Drafting

Yahoo announced that it has launched its new 2013 Fantasy Sports app today, which brings a new design, and new features to the experience.

One of the big new improvements is that it now features mobile drafting, which many will find tremendously helpful. It’s a lot of pressure to be at a computer during draft time.

 

“Managers can now sign up, draft a team and win their league championship from their iOS and Android device thanks to new technology incorporated by Bignoggins Production, Loki Studios and the Yahoo! Sports mobile team,” a spokesperson for Yahoo tells WebProNews. “The app also now features mock drafting, to help fans prepare and get an edge on the competition.”

Yahoo announced its acquisition of Bignoggins just a few weeks ago. They haven’t wasted any time.

“And starting with football, for the first time ever, all of Yahoo! Sports Fantasy games will live under one mobile roof – the Yahoo! Sports Fantasy app – including basketball, hockey and baseball,” the spokesperson adds.

According to Yahoo, the new app is faster than previous experiences. It also has free notifications.

The app is available for iOS and Android.

Attend Meeting C++ 2013

Boost Dependency Analyzer

I have something special to announce today. A tool I’ve build over the last 2 weeks, which allows to analyze the dependencies in boost. With boost 1.53 this spring, I had the idea to build this, but not the time, as I was busy writing a series over the Papers for Bristol. Back then I realized, how easy it could be to build such a tool, as the dependencies could be read & listed by boosts bcp tool. I already had a prototype for the graphpart from 2010. But lets have a look at the tool:

The tool is very easy to handle, it is based on the out of bcp, which is a tool coming with boost. Actually bcp can help you with ripping libraries out of boost, so that you don’t have to add all of boost to your repository when you would like to use smartpointers. But bcp also has a listing mode, where it only shows the dependencies thats whats my tool build up upon. Lets have a short look at the results, the dependencies of boost 1.54:

A few words on how to read this graph. The libraries in the middle of the “starshape” are the ones with the most dependencies, each line between the nodes is a dependency. A dependency can be one or multiple files. The graphlayout is not weighted.

How to

A short introduction on what you need to get this tool to run. First boost, as this tool is build to analyze boost. I’ve tested with some versions (1.49 – 1.54) of boost. You also need a version of bcp, which is quite easy to build (b2 tools/bcp). Then you simply need to start the tool, if BOOST_ROOT is set, the tool will try to read it, other wise you will be asked to choose the location of boost when clicking on Read dependencies. Next thing is selecting the location of bcp. That is the setup, and the tool will now run for some time. On my machine its 90 seconds to 2 minutes the analysis takes, it might be lot longer on yours, depending on how much cores you got. The tool will spawn for each boost library (~112) a bcp process, and analyze this output in a thread pool. After this is done, the data is loaded into the tool, and then saved to a SQLITE database, which will be used if you start the tool a second time and select this version of boost. Loading from the database is far faster.

A screenshot to illustrate this:

tl_files/blog/bda/bda.png

To the left are all the boost libraries, the number of dependencies is shown in the braces. To the right is a Tabwidget showing all the dependencies, the graph is layouted with boost graph. When you click on show all you’ll get the full view of all dependencies in boost. The layouting is done in the background, so this will take some time to calculate, and is animated when its done. The results of the layouting are good, but not perfect, so that you might have to move some nodes. Exporting supports images, which are transparent PNGs, not all services/tools are happy with that (f.e. facebook, twitter nor G+ could handle the perfectly fine images), this can be fixed by postprocessing the images and adding a white background.

Inner workings

I’ve already written a little about the tools inside, its build with Qt5.1 and boost. Where boost is mostly used for the graph layouting. As I choose to work with Qt5, it has a few more dependencies, for windows this sums up to a 18 mb download, which you’ll find at the end. The tool depends on 3 libraries from my company Code Node: ProcessingSink, a small wrapper around QProcess, that allows to just start a bunch of processes, and lets you connect to the finished and error slot. This was necessary, as I could only spawn 62 parallel processes under windows, so this library does take care of spawning the parallel processes now. Which are currently 50 at a time. GraphLayout is the code that wraps the innerworkings of boost::graph, its a bit dirty, but lets me easily process the graphlayouting. The 3rd library is NodeGraph, which is the Graph UI, based on Qts GraphicsView Framework.
I plan to release the tool and its libraries under GPL later on github, for now I don’t have the time to polish everything.

Problems

One of the earliest questions I had when thinking about building such a tool, was where to get a list of the boost libraries? This sounds easy. But I need to have this readable by machine, not human, so HTML is a great format, but I refused to write a parser for this list yet. I talked to some people about this at C++Now, and most agreed, that the second option would be best: maintainers.txt. Thats what the tool reads currently to find the boost libraries. Unfortunately at least lexical_cast is missing in this list. So, the tool isn’t perfect yet, while lexical_cast is already patched, I’m not sure if anything else is missing. A candidate could be signals, as its not maintained anymore. Currently the tool analyzes for 1.54 112 libraries.

boost dependencies

Working for 2 weeks on this tool has given me some inside knowledge about the dependencies in boost. First, the way it is shown in the tool, is the view of bcp. Some dependencies will not affect the user, as they are internal. f.e. a lot of libraries have a dependency to boost::test, simply because they provide their tests with it. The bcp tool really gets you ALL the dependencies. Also most (or was it all?) libraries depend on boost::config. I plan to add filtering later, so that the user has the ability to filter some of the libraries in the GraphView.

The tool

Here is how to get the tool for now: there is a download for the binaries for windows and linux. I’ll try to get you a deb package as soon as I have time, but for now its only the binaries for linux, you’ll have to make sure to have Qt5.1 etc. on linux too, as I do not provide them. For Windows, its 2 archives you’ll need to download: the programm itself, and needed dlls for Qt5.1 if you don’t have the SDK installed ( in this case you also could copy them from the bin directory)

Note on linux: this is a one day old beta version. Will update this later.

WhatsApp Luncurkan Fitur Baru di Windows Phone

Jakarta – WhatsApp is one of the instant messaging service that can be used by many types of cell phone operating system. Not surprisingly, WhatsApp has 250 million active users. According to the Wall Street Journal website, this amount is equivalent to the number of users on Twitter, Facebook Messenger, and Skype.
What’s more, the instant messaging application also does not include ads in their services. Users were not bothered by ads that sometimes appear like the other instant messaging services.
Now, WhatsApp update the application with new features for Windows Phone users. Some of the new features that include
1. Make voice calls;
2. Background API (Application Programming Interface) which can play music;
3. New Smiley;
4. Notifications are updated to the user;
5. Quick summary (if the application is open and the user clicks the notification, the application will open fast like on Android);
6. The user will be asked whether you want to save the conversation history, users can arrange it through the settings menu, and
7. Images are displayed larger.
Updates on Windows Phone devices can be downloaded in Windows Phone Store.

Yahoo!’s Earnings and the Future of Display Ads

Investors were upset that Yahoo! Inc.’s (YHOO) quarterly results showed a sharp drop in display advertising revenue. And, based on its forecasts, that will not get any better soon. The Yahoo! trouble is not an isolated case. Display rates have started to collapse across the industry, making a chance for Internet advertising to expand as fast as it has over the past decade impossible. That represents trouble for tens of thousands of businesses.

Yahoo!’s revenue fell 7% in the second quarter compared to last year, drifting down to $1.22 billion. Wall St. focused mostly on one comment:

Iconic Brands That Just Vanished

GAAP display revenue was $472 million for the second quarter of 2013, a 12 percent decrease compared to $535 million for the second quarter of 2012.

At the same time, there was no evidence that Yahoo!’s audience fell, so the yield from the average display ad fell considerably.

Yahoo! holds a special place among America’s Internet companies. In the United States, according to research firm comScore, it had a monthly audience of unique visitor that was above 192.9 million in May. That put it a very close second to Google Inc.’s (GOOG), which was 193.5 million. Because of its huge size, the trends set by Yahoo! almost certainly represent those of most of the balance of the industry.

States That Drink the Most Beer

The bane of display advertising today is that so many Web properties have decided to stake their futures on content delivered on small devices, which include, primarily, smartphones. All of the evidence indicates that advertisers will pay less for messages they post on these smaller screens. Actually, the amount marketers will pay for this content environment is much, much less than for traditional display ads that appear on personal computers (PCs). In an attempt to chase the online content audience as it migrates away from PCs, Internet companies have badly damaged future revenue prospects. The trouble is that people will watch content on smaller screens whether online content sites like it or not.

Most experts hope that falling display ad rates can be offset by the increase in video content on the Internet. Advertisers will pay a great deal more for video ads than display ads. So, there is a rush to create this sort of programming. But the likelihood that video can balance the drop in display rates appears unlikely.

Beyond Google’s YouTube, the amount of video posted on the Internet by large content companies is relatively small. In May, Google sites had 154.4 million unique video viewers, driven almost exclusively by YouTube. These visitors spent an average of 437 minutes on Google sites in May. After that, video viewership at other sites drops very sharply. For example, Microsoft Corp. (MSFT) sites had 45.2 million unique video viewers in May. The average time these viewers spent watching video on Microsoft sites was only 36.9 minutes, barely more than a half-hour TV show.

Internet advertising may remain at current levels in terms of volume, but the monetary yield from these ads likely will never return.

Easy Solutions Helps Fight Mobile Banking Fraud with Detect Safe Browsing (DSB) 4.0, Now Available for iPhone and Android

Easy Solutions, the Total Fraud Protection® company, today released Detect Safe Browsing (DSB) version 4.0. With DSB 4.0, financial institution can provide an important additional layer of fraud prevention to the end-user, to better protect against malware and other sophisticated threats such as, pharming, man-in-the-middle (MITM) and man-in-the browser (MITB) attacks. With DSB 4.0, Easy Solutions now extends this support to the two most popular mobile platforms: Android and iOS, ensuring that over 90%1 of mobile users can securely access their mobile banking accounts.

The APWG recently reported over 1.3 million confirmed-malicious files for Android alone2, making mobile malware one of the fastest growing classes of threats.

“Mobile banking has become the preferred method for many consumers to conduct their online banking. Unfortunately for financial institutions, some of the most insidious and difficult-to-detect malware is now being targeted at the mobile end-point,” said Daniel Ingevaldson, CTO of Easy Solutions. “With Detect Safe Browsing now available for iPhone and Android devices, financial institutions will be able to provide their customers with a simple and unobtrusive way to secure their mobile banking experience.”

DSB is a critical component of Easy Solutions’ Total Fraud Protection platform, which provides comprehensive fraud protection across all channels, and extended to the end-user. By combining cross-channel risk-scoring, transaction anomaly detection, multi-factor authentication, secure browsing, and detection and take-down services, Easy Solutions blocks criminals at all three phases of the fraud lifecycle – planning, launching, and cashing – while ensuring that authorized users can conduct business.

DSB 4.0 from Easy Solutions provides visibility and real-time intelligence of the threats impacting consumers. Based on a proprietary cross validation technology that prevents re-direction to fraudulent websites, DSB 4.0 includes some of the following capabilities:

  • Secure Mobile Browsing with the DSB App: The free DSB app, now available for both iOS and Android devices, gives customers a simple way to protect bank transactions performed on their mobile device or tablet
  • Accelerated Disinfection: DSB enables customers to quickly deploy on-demand cleanup procedures for malware related advanced persistent threats (APTs), enabling financial institutions to mitigate zero-day and targeted attacks.
  • Active Phishing Protection: DSB provides enhanced phishing protection based on Detect Monitoring Services’ (DMS) black list. Since DMS detects phishing attacks in early stages, DSB users are protected from the very latest phishing scams, minimizing their exposure to fraud.
  • Proactive, Real-time Malware Protection: DSB employs proprietary cross-validation technology that detects DNS poisoning and ensures that the end user can connect to the protected site. When an active redirection is detected, DSB stops the fraudulent connection.

ABOUT EASY SOLUTIONS

Easy Solutions delivers Total Fraud Protection® to over 100 clients, with over 32 million end users. The company’s products protect against phishing, pharming, malware, Man-in-the-Middle and Man-in-the-Browser attacks, and deliver multifactor authentication and transaction anomaly detection. For more information, visit http://www.easysol.net, or follow us on Twitter @goeasysol.

Lenovo IdeaCentre A520 Touch, slim AIO PC

Jakarta, (ANTARA News) – IdeaCentre A520 Touch will soon become a mainstay of Lenovo Indonesia to dominate the market “all-in-one (AIO) desktop PC” in Indonesia with a sleek design and space-saving and very flexible angle capability.

Products launched in Jakarta on Tuesday afternoon it has the same appearance as its predecessor product, the IdeaCentre A720 Touch, which won many awards. What distinguishes the IdeaCentre A520 IdeaCentre A720 Touch Touch is a 23-inch full HD screen without a frame.

IdeaCentre A520 Touch that supports the “10-point multi-touch” screen that has a wide angle that can be adjusted, from minus five degrees to 90 degrees, and IPS LED with a picture perfect view from any angle.

Flexibility IdeaCentre A520 Touch screen allows users to watch movies, play touch-based games or enjoy video chat in any position.

IdeaCentre A520 Touch also comes with an Intel Core i5 processor up to the third generation of the Intel HD Graphics 4000 and 4 Gigabyte DDR3 memory.

The products also have additional features such as Dolby certified speakers with Dolby Home Theater v4, various multimedia applications and games that are optimized for the touch screen.

In addition Touch IdeaCentre A520, Lenovo IdeaCentre B540 Indonesia also launched Touch, a home entertainment center with a 23-inch screen, and the IdeaCentre C540 Touch an affordable and efficient place to use at home.