Monthly Archives: June 2017

Not to be outdone, Ready to Introduce Huawei K3V3 Octa Core Processor newest

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

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

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

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

Creating a 3D Game With Three.js and WebGL

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

Keyboard Applications in Cloud Data Store

Jakarta – Manufacturers keyboard application for tablet computers and smart phones, SwiftKey, SwiftKey has launched a beta version of Cloud.
SwiftKey Keyboard is an Android app that can learn the customs and habits of the user typing text to produce a more predictable.
SwiftKey on Cloud services predecessors, all languages ​​stored on the device. Means, if a user loses his phone, having to learn the application SwiftKey typing habits again. With this new service, users can backup files in the cloud and sync with various devices.
SwiftKey Cloud will also integrate the analysis of data from Twitter and other sources to find a new trending topic. Then bring the words that relate to the topic being the trend for users.
Enterprise application that promises enhanced personal words and phrases as well as integrating predictive Gmail and Facebook. This application can be downloaded free.

Variabel di Shell Script

In the previous issue we’ve become acquainted with a shell script and managed to create a very simple shell script. If we look, we did not perform any processing on the shell script. We only show a message on the screen and execute commands on the shell through shell script. What if we want to make the program more interactive shell script?

As with any programming language, shell script also serves to recognize the variables that can hold information temporarily for a variety of purposes, for example to compute or determine the output results. You may make as much as possible or use a variable in your shell script. Name the variables are independent, large and small letters should, but make it easier to remember, make it a habit to create standard rules in the manufacture of the variable name. At this writing, all variables will be written in lowercase.

Variables can be divided into two types, namely environment variables and user variables. Environment variables are variables that have been previously determined as a part of the shell used (bash). By default, the name of this variable using all capital letters. Example of this is the $ USER variable that will contain the user name you are currently using, $ HOME home directory which contains the address of the user that is used, and so forth. To display the entire value of an existing environment variable, you can use the set command in the terminal (Figure 1). User variable is the variable name specified by the user themselves and not by the shell used.

Variables can be accessed by using the dollar sign ($) before the variable name, for example, we have a variable named “my name”, to access the value stored in the variable, we use the $ my name. To give value to a variable, we use the sign “=” is immediately followed by the value we give without any spaces, for example my name = Willy. What if the value that we want to give is a sentence? Use double quotes as the opening and closing value of a variable, such as my name = “Willy Sudiarto Raharjo”. For example, see listing 1 and try running on your computer. Seen that the value of the variable Sudiarto be regarded as a command and not part of the variable because it is not enclosed in double quotation marks. Please be careful in giving a value to a variable.

You can combine environment variables and user variables in a shell script is the same, as in listing 2. What if want to write a message using the $ character, such as “It cost me $ 15”? If we are not careful, it could be a shell script would be wrong to interpret the information that we provide and try to take the value of variable 1 (which will not contain any) and display it as a “price 5”. To fix this, use the escape character to indicate that the next character will be recognized as a regular character and not as a substitute for a variable, which marks the backslash “\” as in listing 3.

One character that needs more attention is the backtick character “` “(position number 1 on the left side your keyboard) because this character has a special function in shell programming, which is able to accommodate the output of a shell command in a variable. As an example, we will hold the result of the date command into a variable date and display its contents using the echo command as in listing 4.

To be able to receive input from the user and store it into a variable, we can use the read function is followed by the name of the variable that we want to use to store the values ​​as in Example 5 listings.

Application Translators ‘POedit’

Many application developers, Äúmengijinkan, Äù user participated in the development of their software. Typically, one form of user participation that allowed the development of a software is the interface language localization applications. That is, the user is allowed, Äúmenyumbangkan, Äù everyday language used by the user as a language interface applications (usually as a plug-in).

d3-435-POeditNah, some developers of applications that allow the user to localize the interface language is usually included with the file format. PO which can be found in the installation folder. Format. PO is what can be translated, one using poedit.

As the name suggests, poedit CAT is one of the tools with the main function to help, Äúmenerjemahkan, Äù file. PO that will be stored into the format. MO. Berkestensi file. MO is what will be, Äúdikembalikan, Äù to a software installation folder so later a new language will appear in the software language selection menu. For example, there is an application with a file. PO for application interface language in English. Then you translate it into Indonesian with the help of his output poedit that turned into a file. MO. Well, file. MO you, Äúkembalikan, Äù to the application installation folder is what will make the application has a new interface language, the Indonesian language.

Poedit is specific only for files ending in. PO and management does not have as powerful Translation Memory and Glossary premium CAT tools. However, if you are interested to increase flying hours in the field of translation, you can submit a voluntary translation in the field of computing, one of them with the help of this poedit.

3 Reasons to Sell Your Intel Stock

Although Intel (NASDAQ: INTC  ) stock may look cheap compared to theS&P 500, there’s good reason for the low price tag. Between a faltering PC market, anemic revenue growth, and profitability concerns, Intel investors have a lot of things to worry about. Together, these factors certainly beg the question: Should you sell your Intel stock today?

PC sales still top dog
As exciting as it is for Intel to develop cutting-edge technology that threatens ARM Holdings‘ mobile computing stronghold, the company remains deeply entrenched in the PC market. Intelreported its second-quarter earnings results last week, showing that more than 63% of the company’s revenue came from its PC client group segment. With worldwide PC shipments as bad as they’ve been, it’s not surprising that investor enthusiasm would be muted toward the company’s mobile computing ambitions. Simply put, it’s going to take a considerably large tail to wag this dog.

Anemic revenue growth
Without revenue growth, a company’s earnings growth potential is dampened because there’s only so far cost-cutting can take profitability to new heights. Intel lowered its full-year forecast, now expecting revenue to be flat year over year, which doesn’t bode well for profit growth. Analysts expect Intel to post a 12.2% decline in earnings this year and grow by 5.9% in full-year 2014, driven by a 3.9% increase in revenue. For the long-term investor, profitability growth remains a fundamental driver of shareholder returns. Will a 5.9% growth in earnings from a weak comparable be enough to drive Intel stock higher?

Falling prices
Assuming Intel is successful as it gears up to enter the ultra-mobile space with its upcomingBay Trail processor, it’ll likely have a negative impact on the company’s average processor selling price. In order for Bay Trail to gain market share against the ARM competition, I’m expecting its average selling price to be somewhere in neighborhood of Qualcomm‘s, which is about $22 — roughly one-fifth of Intel’s estimated average selling price of $107. Additionally, the mobile computing revolution continues to put negative pressure on the price of PCs, further compounding Intel’s average selling price pressures.

The hope is that any future decline in processor average selling price can be offset with an increase in unit volume, but that’s not guaranteed, nor does it mean total dollar profits will remain stable. Even if Bay Trail can maintain profit margins in line with the rest of Intel’s processors, a $22 or even $30 processor simply doesn’t have as much available profit as a $107 chip.

Ultimately, Intel’s profitability prospects will be driven by a number of variables, including how the overall PC market fares, if average selling prices decline due to consumers shifting to products like Bay Trail, and if Intel can make up any shortfalls with sufficient unit growth. It’s not exactly clear-cut.

No catalyst in sight
We may get a better sense of Intel’s future prospects during its investor meeting in November, but it likely won’t be until its 2014 earnings results that investors begin to get the scoop how these headwinds are actually influencing results. At that time, Intel’s Haswell and Bay Trail processors will have made their run, investors will know if the PC market has begun to stabilize, and we’ll know if ultra-mobile products are hurting Intel’s total profitability thanks to declining prices.

If you’re an Intel shareholder, the question you should ask yourself is if it’s worth waiting around for the clouds of uncertainty to potentially clear up. Being a longtime Intel stock owner myself, I’m seriously considering taking my own advice and selling my shares in the coming weeks. There are plenty of compelling opportunities where the path to long-term shareholder success is much clearer.

Google Selects HE-AAC Multichannel From Fraunhofer IIS For Google Play Movies in Surround Sound

Google and Fraunhofer IIS deliver the first movies with a true 5.1 channel surround sound experience from Google Play. The immersive sound quality consumers have come to expect from TV, Blu-ray disc or DVD is now available with movies streamed or downloaded from Google Play directly to their Android devices running 4.1 or later. Google chose HE-AAC Multichannel as Android’s only surround sound codec due to its open-standard nature and excellent bit-rate efficiency.

When connected to a surround sound system and TV with an HDMI cable, Android users will be able to play high quality audio and video from their smartphones and tablets in surround. On the go, Android devices will play movies in great stereo quality and selected Nexus products will also include the Fraunhofer Cingo virtual surround rendering technology, which will play movies in realistic surround sound on earphones or tablet stereo speakers.

Android’s HE-AAC Multichannel implementation includes full support for loudness and downmix metadata commonly known from the broadcast TV world, as well as other features that allow the sound to be tailored for an optimum user experience in any listening mode and environment.

“Google Play movies in 5.1 HE-AAC Multichannel sound are the first realization of our vision of bringing true theatrical surround sound to mobile devices,” said Robert Bleidt, Division General Manager at Fraunhofer USA Digital Media Technologies. “The Google and Fraunhofer partnership creates a tremendous value for consumers by offering one format that delivers a high quality experience both in-home and while mobile. Consumers may experience surround sound over headphones while on their way home from work, and finish the movie in true, exciting surround in their living room,” he added.

HE-AAC Multichannel is part of the Fraunhofer FDK AAC codec library for Android since version 4.1 and a required feature of all Android-compatible devices. This software makes open-source Fraunhofer implementations of the MPEG audio codecs AAC, HE-AAC, HE-AACv2, and AAC-ELD available to the Android community.

HE-AAC is today’s most efficient high-quality surround and stereo audio codec deployed in over 5 billion devices and used in TV, radio, and streaming services worldwide. The codec is natively integrated into most operating systems, streaming platforms and consumer electronics devices. In addition to its unique coding efficiency, HE-AAC has the dynamic ability to change audio bit-rates seamlessly in order to adapt to changing network conditions as consumers stream content to a variety of devices. It can be used with any adaptive streaming technology including MPEG-DASH, Apple HLS, Adobe HDS and Microsoft Smooth Streaming.

MetaTrader 4 Mobile Now Available for iPhone 5 and All iPad Models

MetaQuotes Software Corp. has released a new version of MetaTrader 4 for iOS devices. The popular mobile application for online trading has received a number of important changes becoming even more user-friendly. The key feature that has been added is native support for all iPad models (including the ones with Retina display) and iPhone 5.

In addition to compatibility with mobile devices, the new version of the application features an enhanced graphical system. It provides a better performance and improved functionality when working with charts. The new version also includes financial news and internal mailbox that allows traders to communicate with broker’s representatives over a secure channel.

“When working on the new version, we were committed to providing compatibility with the new iPhone 5, – said Renat Fatkhullin, CEO of MetaQuotes Software Corp. – But what is most important is support for all iPad models anticipated by many traders. Moreover, the terminal for iPad has greater features than that for iPhone. New MetaTrader 4 iPad is now surely closer to the desktop version in terms of functionality. It features multi-function data window displaying open orders, trading history, email correspondence with a broker and news.

Only desktop version users could enjoy this feature up to now. The application now also features one click trading from a chart, as well as trading history and journal search. All this has been done to facilitate the work of traders. Another important feature of the iPad application is ability to display up to four charts simultaneously. This allows traders to monitor several symbols at a time on a single iPad screen! Thus, the new iPad terminal update tolerates no compromises!”

In general, the mobile terminal for iPhone has become even more convenient due to the improved graphical system. At the same time, apart from native support for devices with all resolutions,MetaTrader 4 iPad offers more opportunities for Forex trading.

According to MetaQuotes Software Corp. developers, similar major changes will soon be also implemented into MetaTrader 5 mobile applications. The new version is already under development.

About the Company

MetaQuotes Software Corp. is a professional developer of software applications for financial markets. With more than a decade of experience, the company is a market leader in the field of forex trading software packages. The MetaTrader 4 trading platform developed by the company is the most popular Forex trading application all over the world.

Company’s website: http://www.metaquotes.net

Comparison Galaxy Note 2 and Xperia Z Ultra

Sony Mobile Communications phablet first official release, Sony Xperia Z Ultra, in Shanghai, China, Tuesday (06/25/2013). This product comes with a capable hardware specs, quad-core processor and a large-capacity battery.

What if Sony Xperia Z Ultra compared with the current best-selling phablet, the Samsung Galaxy Note II? Because, the second Android product will compete directly in the global marketplace.

Here are some differences between the two, as quoted from Trusted Reviews.

Design

Xperia Z Ultra is a jumbo version of the Xperia Z. The device retains the glass material is unbreakable and scratch on the rear panel with a rubber protector for microSD and SIM card slot.

The product weighs 212 grams, much heavier than the Xperia Z (146 grams). Interestingly, Sony is able to preserve the thinness Xperia Z Ultra, which is only 6.5 mm. Currently, he is one of the slimmest phone in the world.

Samsung Galaxy Note 2 has a design that is not much different from the Galaxy S3. The product has a slightly curved shape in the corners, and the use of plastic material. Galaxy Note 2 is slightly thicker than the Xperia Z Ultra, which is 8.6 mm. However, this device is lighter and weighs 177 grams.

Screen

Ultra Z released the Xperia screen “giants”, that is 6.4 inches. Resolutions supported are Full-HD 1080p. The density of the screen is 344 pixels per inch (ppi), is lower than the Xperia Z which reached 441 ppi.

Galaxy Note 2 has a smaller screen, which is 5.5 inches. The resolution was not as high powered Xperia Z Ultra, which is only 1,280 x 720 pixels. So is the 267 ppi screen density.

Stylus

No stylus in Xperia Z Ultra products. However, he supported the use of a pencil or pen and stylus instead. Specifically, the pen must be made of metal with a diameter of more than 1mm.

Meanwhile, the Galaxy Note 2 is equipped with a stylus called S-Pen. This stylus is one of the best on the market. He was able to feel the pressure to 1024 levels. At the end of the “digital pen”, the Samsung has also added a rubber material that make the act of writing feels more natural.

Camera

Xperia Z Ultra comes with an 8 megapixel camera on the back. This camera features digital zoom capability up to 16 times. In addition, there are features face detection, burst mode, HDR, and record video with 1080p quality. At the front, there is a 2 megapixel camera that is also capable of recording 1080p with the quality of.

Galaxy Note 2 adopted specification 8-megapixel camera sensor. There are features of auto focus, face detection, and the selection of the best photos. Front camera has 1.9 megapixel image sensors.

Processor

Xperia Z Ultra armed toplevel Qualcomm processor, with a speed that is 800 Snapdragon 2.2 GHz quad-core.

Galaxy Note 2 use a quad-core processor made by Samsung itself, a speed of 1.6 GHz Exynos 4412. Performance of this processor is capable, but not segahar Qualcomm Snapdragon 800.

Connectivity and Storage Media

Xperia Z Ultra equipped 4G LTE network technology. He is also equipped with NFC that can be connected to speakers, TVs, and SmartWatch 2. In addition, there are Bluetooth 4.0, DLNA, microUSB, Smart Connect, and screen mirroring.

For business storage, Xperia Z Ultra comes with 16GB of internal memory.

Galaxy Note 2 is also equipped with 4G network technology. In addition, there are Bluetooth 4.0, NFC, and features Samsung’s All Share.

This one product is available in three versions of the storage media, namely 16, 32, and 64GB.

Both Xperia Z Ultra and Galaxy Note 2, equipped with a MicroSD memory card slot that can expand up to 64GB of data storage media.

Battery

Both devices have a large battery capacity. Xperia Z Ultra comes with a battery 3.000mAh. While the larger Galaxy Note 2, which 3.100mAh.

MIcrosoft Launches Hardware Certification Requirements for Windows 8.1

Microsoft corporation some time ago has been providing Windows 8.1 Preview can be downloaded for free. And later in August, Microsoft also plans to begin delivering the OS to the notebook and tablet manufacturers.

Now before the second step is done, the Redmond-based company that was recently launched hardware certification requirements for Windows 8.1. The certification was announced by Microsoft at the Worldwide Partner Conference and includes some hardware such as Bluetooth, WiFi, 720p webcam and audio equipment.

The certification also allows for features such as Windows 8.1 Wireless Miracast display, internet sharing, NFC, WiFi Direct print and biometric authentication. However sertfikasi is intended for existing devices in 2014 and 2015. So we’re not going to find it in the near future.