Do you want to use lambda expressions already today, but you are forced to use Java and a stable JRE in production? Now that’s possible with Retrolambda, which will take bytecode compiled with Java 8 and convert it to run on Java 7, 6 and 5 runtimes, letting you use lambda expressions andmethod references on those platforms. It won’t give you the improved Java 8 Collections API, but fortunately there are multiple alternative libraries which will benefit from lambda expressions.

Behind the Scenes

A couple of days ago in a café it popped into my head to find out whether somebody had made this already, but after speaking into the air, I did it myself over a weekend.

The original plan of copying the classes from OpenJDK didn’t work (LambdaMetafactory depends on some package-private classes and would have required modifications), but I figured out a better way to do it without additional runtime dependencies.

Retrolambda uses a Java agent to find out what bytecode LambdaMetafactory generates dynamically, and saves it as class files, after which it replaces the invokedynamic instructions to instantiate those classes directly. It also changes some private synthetic methods to be package-private, so that normal bytecode can access them without method handles.

After the conversion you’ll have just a bunch of normal .class files – but with less typing.

P.S. If you hear about experiences of using Retrolambda for Android development, please leave a comment.

Dynamo ONE Plugin, known as the easy button for WordPress , which is owned and supported by Plugin Dynamo, is excited to announce the release of an upgrade to the Dynamo ONE Plugin. The upgrade enhances the amazing Dynamo ONE Plugin making it even more seamless and effective at setting up WordPress blogs. The Dynamo ONE Plugin allows users to configure and set-up their WordPress site into a highly optimized SEO site in less than 90 seconds.

This upgrade improves how the Plugin syncs with the user’s account for activation and the new layout is a simple 6 click process. This new process will allow users to set-up their WordPress site in less time with less mistakes.

Wesley Williams, Plugin Dynamo’s Managing Partner said, “The Dynamo ONE Plugin was the 1st Plugin to integrate the SEO settings and basic Plugin requirements into one Plugin to make the entire process easy for the user. This update demonstrates our continued support and push to simplify the WordPress set-up process.”

About the Dynamo ONE Plugin:
Dynamo ONE Plugin was created by Plugin Dynamo and is a one of a kind tool that enables users to save time when configuring and setting up WordPress sites. For people who want to configure and set up their WordPress sites quickly and effectively, Dynamo ONE Plugin is the most ideal tool. It allows users to make their WordPress sites SEO friendly and highly optimized in a matter of seconds.

About Plugin Dynamo:
Plugin Dynamo is owned and operated by dotCOM Interactive based in Dallas Texas. Since 2010, Plugin Dynamo has been producing easy to use Plugins. Its Plugins are regularly updated to incorporate new ideas from users, and also to ensure that they are in harmony with the latest versions of WordPress. Plugin dynamo is committed to offering valuable support to its customers.

Prerequisites

  • A browser with WebGL – this game has been tested on Chrome and Firefox. IE still doesn’t support WebGL, unless you’re using Windows 8.1 with IE11.
  • Three.js library available for download from the Three.js website
  • The Keyboard.js helper library I used for this project, created by Arthur Schreiber at No Karma. Download it from my GitHub repository
  • A basic understanding of what Three.js does. Read this super simple, super quick tutorial by Paul Lewis. It’s basically a short-hand version of this article.

Setup

Get a base index.html running

Step one when making a web-based game is to create the host index.html file. In our case, it only needs to be a very simple set of elements, so we can bundle the CSS styling too.

Import Keyboard.js and Three.js

Three.js is a library contained in just one JavaScript file, so we can grab the minified version from the website.

For Keyboard input, we will need to referencethe aforementioned JavaScript file in our index.html as well.

Create setup() and draw() functions

The setup() function will be the start point for the game code. The draw() function will be run every frame and will handle all the rendering and game logic.

In order to loop the draw() function, we simply utilise the requestAnimationFrame() function call, and pass ‘draw’ as the parameter. Remember, not all browsers natively support the call, and you might have to use Paul Irish’s shim to gain maximum compatibility. Also, it is important to realise that requestAnimationFrame() does not guarantee a fixed frame-rate, so you need to use time-deltas to calculate realistic physics. For a basic game like Pong, we don’t really care about that.

Basic World

Set up the Three.js world and camera

Three.js includes these important elements:

  • Scene
  • Renderer
  • Camera
  • Mesh
  • Light
  • Material

Cameras, Meshes, and Lights need to be added to the scene using the scene.add() function.

Attach a WebGL Three.js Renderer to the DIV

The renderer is attached to whichever HTML DOM element you wish to render the scene to, and a render() call is made each frame to the renderer in order to draw the Three.js scene.

Add a camera to the scene

Three.js has the option to create Perspective and Orthographic cameras. For most uses, Perspective camera is the best choice. We can change position and rotation information of the camera like any other object in the scene.

Draw a sphere and light it

Meshes must be paired with Materials in order to give them a defined look and feel. Meshes can be of many types, include primitives such as Cube, Sphere, Plane and Torus. Materials can have different characteristics depending on their type. The basic Material types include Lambert, Phong, and Basic.

  • Basic renders an unlit Mesh with no shadows or dark shading. A sphere will look like a circle if rendered with Basic.
  • Lambert is a simple diffuse-like lighting that creates shading on sides facing away from a light source. It gives a basic 3D look of surfaces that are matte (non-shiny and non-reflective)
  • Phong is used for achieving a plastic-like look and feel, with the ability to gain highlights that give a much shinier appearance to the Mesh.

Show off your sphere with a Point Light. This is the most basic light, with no direction or rotation. Make sure you tweak the light’s intensity and distance to get it looking good.

Add Game Objects

Draw playing area plane

The playing area will be a Three.js Mesh object of type Plane. Make sure the plane matches the play area, giving a small buffer gap to indicate where the paddles can and can’t go.

Draw paddles

The paddles will be Mesh objects of type Cube. Position each of the paddles on opposite sides of the play area.

1234567891011121314151617181920212223242526272829303132333435363738394041
// set up the paddle vars
paddleWidth = 10;
paddleHeight = 30;
paddleDepth = 10;
paddleQuality = 1;
// set up paddle 1
paddle1 = new THREE.Mesh(
new THREE.CubeGeometry(
paddleWidth,
paddleHeight,
paddleDepth,
paddleQuality,
paddleQuality,
paddleQuality),
paddle1Material);
// add the paddle to the scene
scene.add(paddle1);
// Set up the second paddle
paddle2 = new THREE.Mesh(
new THREE.CubeGeometry(
paddleWidth,
paddleHeight,
paddleDepth,
paddleQuality,
paddleQuality,
paddleQuality),
paddle2Material);
// Add the second paddle to the scene
scene.add(paddle2);
// set paddles on each side of the table
paddle1.position.x = -fieldWidth/2 + paddleWidth;
paddle2.position.x = fieldWidth/2 – paddleWidth;
// lift paddles over playing surface
paddle1.position.z = paddleDepth;
paddle2.position.z = paddleDepth;
view rawBNG_Pong_paddlecreateThis Gist brought to you by GitHub.

If you manipulate the camera positions, as seen in the screenshot, you can give a different perspective to the player.

Basic Logic

Ball movement

The ball will have an X-direction and a Y-direction that determines the movement per frame.

// ball’s x-direction, y-direction and speed per frame
var ballDirX = 1, ballDirY = 1, ballSpeed = 2;

The ball will move at a constant speed in the X-plane every frame. To this end, we will specify a ballSpeed variable that acts as a multiplier for the direction values.

// update ball position over time
ball.position.x += ballDirX * ballSpeed;
ball.position.y += ballDirY * ballSpeed;

We want the ball to have some unpredictable characteristics (e.g. when it gets sliced quite hard) so we will allow the Y-direction to go up to a maximum of ballSpeed * 2. You can tweak the values until you’re happy with how the ball behaves.

// limit ball’s y-speed to 2x the x-speed
// this is so the ball doesn’t speed from left to right super fast
// keeps game playable for humans
if (ballDirY > ballSpeed * 2)
{
ballDirY = ballSpeed * 2;
}
else if (ballDirY < -ballSpeed * 2)
{
ballDirY = -ballSpeed * 2;
}

Ball wall bounce logic

Simple collision detection logic is required to check if the ball is touching each of the side ‘walls’. Using a series of ‘if-else’ statements, we check the ball positions against the predetermined wall positions. In the case of a collision, we simply switch the Y-direction of the ball, creating a bounce effect.

// if ball goes off the top side (side of table)
if (ball.position.y <= -fieldHeight/2)
{
ballDirY = -ballDirY;
}
// if ball goes off the bottom side (side of table)
if (ball.position.y >= fieldHeight/2)
{
ballDirY = -ballDirY;
}

Later, we will edit some of this code in order to implement scoring when the ball passes a paddle.

Keyboard input for paddles

We will utilise a very effective short-cut in order to easily get keyboard input working in this game. Using the Keyboard.js file provided, we simply have to include the reference to it in the index.html file and we are set. Only one function call is required, the Key.isDown() call. Given a parameter, the library checks if that particular key is current being pressed, and returns a boolean value.

// move left
if (Key.isDown(Key.A))
{
// code to move paddle left
}

We use the ‘A’ and ‘D’ keys to move the paddle left and right, but you can edit the Keyboard.js with additional values if you want to use your own control scheme.

var Key = {
_pressed: {},
A: 65,
W: 87,
D: 68,
S: 83,
// add your required key code (ASCII) along with the name here
// for example:
SPACE: 32,
};

While dealing with keyboard input, it is also important to ensure that the input is never blindly updated in game. We have to check that the paddle isn’t made to move off the play area, and we do that with some ‘if-else’ statements as well.

// move left
if (Key.isDown(Key.A))
{
// if paddle is not touching the side of table
// we move
if (paddle1.position.y < fieldHeight * 0.45)
{
paddle1DirY = paddleSpeed * 0.5;
}
// else we don’t move and stretch the paddle
// to indicate we can’t move
else
{
paddle1DirY = 0;
paddle1.scale.z += (10 – paddle1.scale.z) * 0.2;
}
}

Note that we use a paddle direction variable, rather than simply applying a change to the position values. This will come in handy when programming the ball to ‘slice’ when hit at an angle with a fast-moving paddle.

Opponent logic

When you code a game of this calibre, it is of utmost importance that you create a vivid, lush environment with a host of emotional, highly-relatable characters that showcase this generation’s strides forward in technology. Instead, we will code a Pong A.I. that blindly follows the ball, because that is even better.

We can update the opponent difficulty by using a variable instead of introducing magic numbers. This variable will affect the ‘reaction rate’ of the opponent by increasing the Lerp (Linear-Interpolation) time.

When using a Lerp (Linear-Interpolation) function, we must ensure the opponent plays fairly by limiting their maximum travel speed. We do that with a few more if-else statements.

// in case the Lerp function produces a value above max paddle speed, we clamp it
if (Math.abs(paddle2DirY) <= paddleSpeed)
{
paddle2.position.y += paddle2DirY;
}
// if the lerp value is too high, we have to limit speed to paddleSpeed
else
{
// if paddle is lerping in +ve direction
if (paddle2DirY > paddleSpeed)
{
paddle2.position.y += paddleSpeed;
}
// if paddle is lerping in -ve direction
else if (paddle2DirY < -paddleSpeed)
{
paddle2.position.y -= paddleSpeed;
}
}
If want to extend immersion, you could also using the paddle.scale property to stretch the paddle when it can’t be moved. This indicates an issue to the player which they can then address immediately. In order to accomplish this, we must ensure the paddle always Lerps back to the default scale size.
// We lerp the scale back to 1
// this is done because we stretch the paddle at some points
// stretching is done when paddle touches side of table and when paddle hits ball
// by doing this here, we ensure paddle always comes back to default size
paddle2.scale.y += (1 – paddle2.scale.y) * 0.2;

Adding Gameplay

Making the ball reset after missing a paddle

To get the main scoring gameplay working, we need to first remove the ball’s ability to bonce off the paddle-facing walls. To do this, we remove the bounce code from the two corresponding if-else statements.

// if ball goes off the top side (side of table)
if (ball.position.y <= -fieldHeight/2)
{
ballDirY = -ballDirY;
}
// if ball goes off the bottom side (side of table)
if (ball.position.y >= fieldHeight/2)
{
ballDirY = -ballDirY;
}
//// ——————————— ////
CHANGED CODE
//// ——————————— ////
// if ball goes off the ‘left’ side (Player’s side)
if (ball.position.x <= -fieldWidth/2)
{
// CPU scores a point
// update scoreboard
// and reset ball
}
// if ball goes off the ‘right’ side (CPU’s side)
if (ball.position.x >= fieldWidth/2)
{
// player scores a point
// update scoreboard
// and reset ball
}

We can handle scoring in many different ways. For a simple game like this, we can simply increment the corresponding score count variable.

// if ball goes off the ‘left’ side (Player’s side)
if (ball.position.x <= -fieldWidth/2)
{
// CPU scores
score2++;
// update scoreboard HTML
document.getElementById(“scores”).innerHTML = score1 + “-” + score2;
// reset ball to center
resetBall(2);
// check if match over (someone scored maxScore points)
matchScoreCheck();
}

We can then update the HUD element in the DOM by setting its innerHTML value. Finally, we have to reset the ball once someone has scored. A simple function can be written to reset the ball, with a parameter indicating which paddle just lost (so we know which paddle to send the ball to next time).

// resets the ball’s position to the centre of the play area
// also sets the ball direction speed towards the last point winner
function resetBall(loser)
{
// position the ball in the center of the table
ball.position.x = 0;
ball.position.y = 0;
// if player lost the last point, we send the ball to opponent
if (loser == 1)
{
ballDirX = -1;
}
// else if opponent lost, we send ball to player
else
{
ballDirX = 1;
}
// set the ball to move +ve in y plane (towards left from the camera)
ballDirY = 1;
}

Making the ball bounce off paddles

Alright, this is it. The big one. Literally the biggest feature of this game. It’s time to get the paddles hitting the ball. In a simple Pong game, paddle-ball physics are nothing more than a couple of if-else statements. We check the X-position and Y-position of the ball against the paddle’s rectangular bounds, and if they intersect, we bounce the ball away.

// if ball is aligned with paddle1 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle1.position.x + paddleWidth
&& ball.position.x >= paddle1.position.x)
{
// and if ball is aligned with paddle1 on y plane
if (ball.position.y <= paddle1.position.y + paddleHeight/2
&& ball.position.y >= paddle1.position.y – paddleHeight/2)
{
// ball is intersecting with the front half of the paddle
}
}

It’s also important to check the direction of the ball’s travel, as we only want to check collisions in one direction (the direction towards the opponent.)

// and if ball is travelling towards player (-ve direction)
if (ballDirX < 0)
{
// stretch the paddle to indicate a hit
paddle1.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle1DirY * 0.7;
}

We will also affect the ball’s lateral movement depending on the relative speed of the paddle when hitting the ball. This is particularly useful in introducing the biggest variable in Pong: the slice. Slicing the ball is often the only way to confuse and outmaneuver the opponent, so it is vital in this game.

Remember to duplicate the code, but update the values to match the opponent’s paddle. You can use this opportunity to gimp your opponent’s ability somewhat, by reducing the hitbox size or decreasing the slice amount. It’s what we would all do.

Here is the final paddle-ball collision function:

// Handles paddle collision logic
function paddlePhysics()
{
// PLAYER PADDLE LOGIC
// if ball is aligned with paddle1 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle1.position.x + paddleWidth
&& ball.position.x >= paddle1.position.x)
{
// and if ball is aligned with paddle1 on y plane
if (ball.position.y <= paddle1.position.y + paddleHeight/2
&& ball.position.y >= paddle1.position.y – paddleHeight/2)
{
// and if ball is travelling towards player (-ve direction)
if (ballDirX < 0)
{
// stretch the paddle to indicate a hit
paddle1.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle1DirY * 0.7;
}
}
}
// OPPONENT PADDLE LOGIC
// if ball is aligned with paddle2 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle2.position.x + paddleWidth
&& ball.position.x >= paddle2.position.x)
{
// and if ball is aligned with paddle2 on y plane
if (ball.position.y <= paddle2.position.y + paddleHeight/2
&& ball.position.y >= paddle2.position.y – paddleHeight/2)
{
// and if ball is travelling towards opponent (+ve direction)
if (ballDirX > 0)
{
// stretch the paddle to indicate a hit
paddle2.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle2DirY * 0.7;
}
}
}
}
view rawBNG_Pong_paddlecollCompleteThis Gist brought to you by GitHub.

Scoring

In Pong, it is usually simplest to have a maximum score value, such that a game is won when either player reaches that score. To that end, we can easily create a maxScore variable and set it at the start of the match.

We then create a function to check if either player has scored equal or higher than the maximum. This function should be called only when a score has been changed (i.e. when someone scores a point.)

// checks if either player or opponent has reached 7 points
function matchScoreCheck()
{
// if player has 7 points
if (score1 >= maxScore)
{
// stop the ball
ballSpeed = 0;
// write to the banner
document.getElementById(“scores”).innerHTML = “Player wins!”;
document.getElementById(“winnerBoard”).innerHTML = “Refresh to play again”;
}
// else if opponent has 7 points
else if (score2 >= maxScore)
{
// stop the ball
ballSpeed = 0;
// write to the banner
document.getElementById(“scores”).innerHTML = “CPU wins!”;
document.getElementById(“winnerBoard”).innerHTML = “Refresh to play again”;
}
}

After a match is deemed complete, it is simplest to just return the ball to the centre and stop any movement, so that play doesnt inadvertently continue.

Prettifying the Game

HUD

It’s important to give feedback to the player so they know what’s going on. For Pong, the least we can do is keep a scoreboard ticking over. Instead of trying to draw the HUD on the same layer as the game, we can use the other DOM elements to provide the required feedback.

It’s also good to indicate the maximum score as well, so we have another element for that which we will update at match start.

// update the board to reflect the max score for match win
document.getElementById(“winnerBoard”).innerHTML = “First to ” + maxScore + ” wins!”;

Shadows

Finally, it is time to make things look a tad more polished. Three.js has the awesome ability to create shadows for primitive objects (Cube, Plane, Sphere, etc.) so we can utilise that to make the game look nicer.

Shadows can’t be created with just a Point light, so we have to add a DirectionalLight or a SpotLight. A SpotLight shines a circular beam of light onto surfaces, which DirectionalLight simply shines a light in a certain direction with no regard to positioning.

We will use a SpotLight because it clearly indicates where the light originates from and shines towards.

We can update the SpotLight to follow the ball around to give a more dynamic look and feel to the game, whilst showcasing the hard work we just put into the lighting.

// we can easily notice shadows if we dynamically move lights during the game
spotLight.position.x = ball.position.x;
spotLight.position.y = ball.position.y;

To make an object in the scene cast or receive shadows, we simply set their .receiveShadow and .castShadow variables to true. For example,

paddle1 = new THREE.Mesh(
new THREE.CubeGeometry(paddleWidth, paddleHeight, paddleDepth, paddleQuality, paddleQuality, paddleQuality),
paddle1Material);
// add the sphere to the scene
scene.add(paddle1);
paddle1.receiveShadow = true;
paddle1.castShadow = true;

Conclusion

This is but a basic introduction to the power of Three.js, which should allow you to create a basic Pong clone.

Play the latest build of this game here: LATEST BUILD*

Find the latest code at its GitHub page*

You can still do quite a number of things to polish your game, such as

  • Create animations for the paddles and ball
  • Update the HUD to look prettier
  • Import complex objects created in Modeling packages, to design a more immersive environment
  • Move HUD elements inside the game view to allow for full-screen gaming
  • Mess around with complex shaders to create reflections and other cool effects

Having announced a few days ago, 7 of the Google Nexus tablet could have ordered via the Play Store. Opening the pre-order was first announced via Twitter. Google Play Store opened bookings for the new Nexus 7 16GB and 32GB. Both are offered at a price of USD 229 and USD 269.
Almost simultaneously with the opening of pre-orders, it also gives Google Nexus 7, this new software update. There are 2 updates are given, with the first update will be automatically downloaded to the tablet when connected to the Internet for the first time during initial setup.
As for the second update will be downloaded automatically when the tablet is used several times. The update notification will appear when it’s finished downloading and is ready to be installed. So make sure that the type of connection used unlimited when activating new Nexus 7 so as not to run out of quota.

Facebook Inc’s mobile advertising success offers a ray of hope for Internet companies trying to make money within the confines of the smartphone’s small screen.

The social network’s 75 percent surge in mobile ad revenue in a span of just three months not only doused skepticism on Wall Street and Madison Avenue about Facebook’s business prospects, some say it could serve as a how-to guide for other Web companies navigating a world where the phone and tablet have fast become the screens of choice.

Facebook’s “Newsfeed” ads, which inject marketing messages straight into a user’s content stream and are tailored for mobile devices, were the stars behind the social network’s stunning numbers on Wednesday.

“You’re going to see a lot of companies transitioning and trying to emulate this model because it’s working so well. That’s why last night was a true watershed moment,” said Ben Schachter, an analyst at Macquarie Research.

Internet company executives have long been concerned that mobile advertising is inherently less lucrative than traditional desktop PC advertising, due to the smartphone’s limited screen size and possible consumer resistance to a flood of ads on their devices.

Companies from Google Inc and Yahoo Inc to upstarts such as Snapchat are searching for the right formula to monetize mobile services. While Google has developed a mobile ad business generating an estimated $10 billion a year in revenue, it remains much smaller and less lucrative than Google’s desktop search advertising. Analysts expect Google to generate $60 billion in annual revenue this year.

That wholesale exploration of “native ads” – or marketing messages intended to blend with a users’ personal content, rather than stand out as an ad – has met with varying success.

Twitter, which pioneered the concept of the in-stream ad even before Facebook, may also be well-positioned to benefit from mobile ads. “Sponsored” messages now pop up abruptly in the middle of streams of tweets, but analysts say the frequency is much lower on Facebook newsfeeds.

More than half of the privately held company’s revenue will come from mobile ads this year, reckons Clark Fredricksen, at industry research firm eMarketer.

Some are just getting into the game. This week, LinkedIn Corp, the network for business professionals, rolled out in-stream ads on mobile and PC versions of its service. Yahoo has experimented with similar types of ads, and acquired blogging hub Tumblr for $1.1 billion in May, in part to jumpstart efforts at developing new formats.

But it’s Facebook, which a year ago had zero mobile revenue, that has most aggressively promoted its mobile advertising business to Madison Avenue – with seeming success.

“Compared to other companies, nobody has come right out and said mobile is our sole focus now,” said Angela Steele, CEO of Ansible, part of advertising holding company IPG. “Facebook put all their eggs in one basket.”

FOLLOWING SUIT

One longstanding question has been how much tolerance consumers have for ads that disrupt their stream of content. Facebook said it has steadily increased the number of ads in the news stream without noticing a drop in user satisfaction.

Facebook Chief Executive Mark Zuckerberg said on Wednesday that, on average, ads now account for 5 percent or one in 20 “stories” in the newsfeed. That ratio could now provide a baseline for calculating success, prompting other Web companies to raise the frequency of ads in their streams.

“It wouldn’t surprise me if other companies would look at that and follow suit,” said Ansible’s Steele.

Hussein Fazal, the CEO of AdParlor, which manages advertising campaigns on Facebook, guesses that the social network must have gradually opened the spigot, gauging user reaction and adjusting the stream all the while.

They seemed to have hit on the right formula, but it’s one that differs across platforms, he said.

“The reason Facebook can do it is, the rest of the content that’s there is so engaging that you don’t mind one out of every 20 ads,” he said. “If you have a newsfeed that’s not so engaging, and you keep seeing ads, then it doesn’t work.”

Plus, the more ads in the stream, the less users will click on them, which can dampen ad prices, he added.

Facebook’s seeming success on mobile devices contrasts with Google’s more gradual improvement in that area. The No. 1 Internet search engine has gradually managed to narrow declines in its overall ad rates from the mobile effect, but last quarter they reversed and went down again, disappointing investors.

Google has avoided news stream ads entirely in its Google+ social network. Instead, its mix of mobile search ads, video ads and innovative formats such as “click-to-call” have delivered what RBC Capital Markets analyst Mark Mahaney estimates is a $10 billion annualized run rate for its mobile business, about four times as much as Facebook.

But mobile has driven down the average cost of Google ads, and some industry watchers consider the transition a long-term threat to the search giant. But other analysts say recent changes to the way it sells ads to marketers, blurring the distinction between the mobile and PC, could help bolster rates.

Some time ago, mobile phones HTC has officially launched in Indonesia. This smart phone can be considered quite innovative and brought some technology like the HTC BlinkFeed, Zoe HTC, HTC and HTC Sense BoomSound. Such features make this smart phone is different compared to other Android phones. To reach consumers who preyed HTC cheaper and smaller, HTC has launched the HTC Mini in Indonesia.

Arguably HTC Mini is a mini version and lighter than previous versions of HTC. This smart phone has embedded 1.4 GHz Qualcomm Snapdragon processor core 400 using two with Adreno 305 graphics. In addition, this phone is using the Android operating system V 4.2.2 Jelly Bean.

 

For full technical specifications from one HTC handset are as follows:

4.3 “720 x 1280 Super LCD2 capacitive touchscreen Corning Gorilla Glass 3
HTC Sense, HTC Blinkfeed, Boomsound HTC, HTC and HTC Zoe Ultrapixel
Qualcomm Snapdragon Processor 400 Dual Core 1.4 GHz
Adreno 305 GPU
1 GB of RAM
16 GB internal capacity
4-megapixel rear camera and 1.6 megapixel front camera
Micro USB 2.0 connectivity, DLNA, Bluetooth, and Wifi
Already equipped with Android Jelly Bean version (4.2.2)
As seen above, the hardware specs of HTC HTC Mini One to see cuts. However this phone still has good hardware specs and still be able to enjoy the features of HTC BlinkFeed, Zoe HTC, HTC and HTC Sense BoomSound innovative. To use the camera itself is still the 4-megapixel resolution with HTC Ultrapixel technology. From the look of the phone, similar to the HTC One and still made of aluminum but with a plastic periphery.

The phone is perfect for those who want to try and enjoy the features of HTC but with a cheaper price. For in Indonesia itself about the price and when it was officially sold there is still no clear information, the new HTC Mini HTC just introduced officially in Indonesia

Processors are getting faster, increasing the screen resolution and packaging design into its own color thinning on the development of smartphones and tablet PC technology today. With the presence of the latest innovation from LG, the trend will continue. LG introduces the thinnest Full HD display panel in the world for mobile devices. With this innovation, the body seems to be getting thinner smartphone.
LG LCDpanel 1 world slimmest Full HD LCD Panel Thinnest In The World For Mobile Devices From LG smartphone mobile gadget news
LCD Panel Full HD Thinnest In The World For Mobile Devices From LG
LG’s latest display panels present in the 5.2-inch size. There is a possibility this panel will be present in larger sizes for use on Tablet PCs. Thickness is only 2.2 mm, including the bezel or frame size 2.3 mm. The key to the success of creating a panel LG world’s thinnest LCD screen is located on LG Display panel technology, Advanced One-Glass-Solution (OGS). Even to create, LG brings touchscreen technology that is specifically designed and applied the first time through this panel.
2 LCDpanel world slimmest LG LCD Panel Full HD Thinnest In The World For Mobile Devices From LG smartphone mobile gadget news
LCD Panel Full HD Thinnest In The World For Mobile Devices From LG
So what’s the secret to this panel can be very thin? The secret lies in between the display panel and touch the film (layer touch screen). LG Dual Flexible Printed circuit inserts instead of regular single circuit. All components are then combined with Optical Clear Resin parts in between the panel and touch the film with immediate unification system. As a result, it will automatically reduce the thickness of the panel itself as much as 30 percent.
With the presence Optical Clear Resin, this new tech screen brightness can have a better screen. With a full HD screen resolution of 1920 × 1080 pixels and it has a maximum level of 535 nits brightness, the LCD screen of LG’s latest look more perfect and claimed to still be clearly visible even under the conditions used in the scorching sun.
Unfortunately, LG has not announced when the LCD screen will make her debut for smartphones and tablet PCs. Most likely we will see it the first time in LG branded products.

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.

Accela, Inc., the leading provider of civic engagement solutions for government agencies, announced today that its Civic Hero app is now available for Windows 8. With Civic Hero for Windows 8, Accela is providing entire communities with an innovative app that empowers citizens to report non-emergency community issues such as graffiti, potholes, or damaged public property to local government.

“We’re very excited that Civic Hero is now available on Windows 8,” said Maury Blackman, Accela President and CEO. “This opportunity provides an amazing user experiences and offers features that will delight our user base. Now more government agencies and citizens will be able to access our expanding platform of applications and will realize the true value of citizen engagement. We look forward to continuing to work closely with Microsoft to bring additional apps to market.”

By using their Windows 8 devices, citizens can simply select the type of issue they are reporting, take or add a quick photo or comment and they are done. Citizens can also review and comment on issues reported by others. Government agencies will benefit from utilizing Civic Hero in the following ways:

  • Automatic report routing to only receive service requests within your jurisdiction and areas of responsibility.
  • Tight integration with Accela Automation, allowing agencies to leverage the workflow engine to assign and track reports.
  • Prioritization of reported issues through community feedback.
  • Elimination of duplicate requests.
  • Good will from citizens when they utilize a convenient and useful app that makes communicating with government easy and efficient.

“Civic Hero for Windows 8 offers significant benefits to government agencies and citizens by enabling a fast and transparent method for reporting non-emergency issues,” said Steve Jenkins, senior director of government partners, Microsoft Worldwide Public Sector. “Accela’s easy-to-use app helps cities, citizens and government employees stay engaged with their communities on their Windows 8 devices with convenient access virtually anywhere.”

The Windows 8 version of Civic Hero joins existing versions deployed on leading mobile platforms including iOS and Android. For more information on Accela’s mobile applications, including Civic Hero, visit www.accela.com/civic-apps.

About Accela

Accela, Inc. provides the leading civic engagement platform, powering thousands of services and millions of transactions daily for large and small public agencies worldwide. We connect government to people and accelerate and streamline land management, licensing, asset management and public health and safety processes. Accela’s Civic Cloud includes a complete platform, both packaged and tailored solutions and cloud-based, office, mobile and social applications to support government agency, business and citizen needs. Accela is headquartered in San Ramon, Calif., with international offices in Australia and the United Arab Emirates. For more information, visit www.accela.com.

Guidewire Software, Inc. (GWRE), a provider of software products for Property/Casualty (P/C) insurers, today announced that it has received five of six 2013 Vanguards in Insurance Practices (VIP) Awards. The VIP Awards are sponsored byInsurance Networking News (INN) in partnership with Celent and were announced and presented at the recent ACORD LOMA Insurance Systems Forum in Las Vegas. The VIP award winners were solely determined by insurance company professionals through their participation in an online survey where they were asked to name technology providers that deliver the most value in various VIP categories.

Guidewire’s 2013 VIP awards included recognition in the Back Office & Support Systems, Customer Experience Solutions, Decision Support Solutions, Insurance Core Solutions, and Strategic Partner categories. More information about the 2013 VIP Awards can be found at www.guidewire.com.

“The VIP awards identify the leaders in insurance technology and recognize the vendors that best help insurance carriers meet the increased expectations of consumers and agents,” said Carrie Burns, editor-in-chief, INN. “This year, we’ve seen that while insurers still consider customer service and stability to be important traits of vendors, the ability to plan for advances in technology is becoming just as important.”

“Guidewire is very effective in building and supporting their partner networks, and their customers appreciate that choice of implementation partners,” said Chuck Johnston, director, Celent. “They’ve also built out a solid organization that has connected with their customers and created good rapport, as seen in the award results. They’ve made significant investments in pertinent technologies to support their customers, also reflected in the award results.”

“It is a great honor for the Guidewire team to be recognized especially given that the award rankings are based solely on feedback from P/C insurance professionals,” said Brian Desmond, vice president, Marketing, Guidewire. “We thank Insurance Networking News and Celent for sponsoring the VIP awards program, and we thank everyone who participated in the survey.”

This year is the seventh annual VIP ranking of technology solution providers to the insurance industry. 2013 winners were chosen based on votes from 476 unique respondents.

About Insurance Networking News

Insurance Networking News is a trusted source for information on how technology is being implemented to support insurers’ strategic business objectives, providing insightful analysis of the technology innovations utilized to automate critical processes. Insurance Networking News is written to help senior insurance executives obtain mission-critical information on resolving industry challenges.

About Guidewire Software

Guidewire Software is a provider of software products for Property/Casualty insurers. Designed to be flexible and scalable, Guidewire products enable insurers to deliver excellent service, increase market share, and lower operating costs. Guidewire products include Guidewire InsuranceSuite™, consisting of Guidewire PolicyCenter®, Guidewire ClaimCenter® and Guidewire BillingCenter® which span the core functional areas in insurance; Guidewire LiveSM, a cloud-based network connecting peer insurers, core system data and expert tools through instant on apps; Guidewire DataHub™ and Guidewire InfoCenter™ which help insurers address their data management and business intelligence challenges.