Rocket Software Releases Rocket z/SQL

Rocket Software, Inc. (www.rocketsoftware.com) today announced the general availability of Rocket z/SQL for IBM System z customers who are ready to turn their valuable petabytes of non-relational data into actionable intelligence. Rocket z/SQL is a new product that allows mainframe data to better integrate with enterprise business intelligence and analytics initiatives while reducing cost and complexity.

“We recognize that data is a huge challenge, and a huge opportunity, for our customers,” says Sam Elias, Rocket Vice President and General Manager. “Our customers see real value in accessing their data in place with standard off the shelf tools that speak SQL. Rocket z/SQL makes non-relational data as simple to access as an Excel spreadsheet.”

“We are rapidly heading towards a world of analytics everywhere,” said Dan Sommer principal research analyst at Gartner. “Gartner predicts that analytics will reach 50 percent of potential users by 2014. By 2020, that figure will be 75 percent, and we will be in a world where systems of record, systems of differentiation and systems of innovation are enabling IT, business and individuals to analyze data in a much denser fashion than before.”

Rocket z/SQL gives organizations industry-standard access to non-relational mainframe data without moving data off the mainframe. Traditional approaches require complex techniques, steps, and processes that move, copy, and transfer mainframe data before information can be used by applications and decision makers. With Rocket z/SQL, data is accessible in place through any SQL tool. Rocket z/SQL utilizes patent-pending integration architecture to perform all data transformations and joins in place – on the mainframe – with significantly reduced processing costs.

About Rocket Software

Rocket Software (www.rocketsoftware.com) is a global software development firm that builds enterprise products and delivers enterprise solutions in the following segments: Business Intelligence and Analytics; Storage, Networks, and Compliance; Application Development, Integration, and Modernization; and Database Servers and Tools

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

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.

Mozilla ponders blinkers for your browser

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

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

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

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

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

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

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

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

8 Benefits of Studying Vocabulary. How one can Boost your Creativeness? Tips on how to Provide an Fantastic Convincing Speech?

8 Benefits of Studying Vocabulary. How one can Boost your Creativeness? Tips on how to Provide an Fantastic Convincing Speech?

When obtaining a completely new expertise, it is vital to self encourage for much more behavior. It seems reasonable of understanding along with permits you to definitely take into account a summary of advantages that will be a tool. Studying often takes a lengthy time so a criminal must defeat instances of indifference. Take into account the most pleasant great things about understanding a completely new terminology. Read More »

Application Encryption VSEncryptor

File Protector Portable Applications

VSEncryptor is an application that can be petrified our encryption protects files and text by scrambling the contents and form of the original will only display such content if the correct password is entered.

Portable VSEncryptorVersi this application is free. However, although it does not require installation, by default it has several options to change the entries in the registry. If you choose to install this application, note that it will replace the search engine and homepage in Internet Explorer and Mozilla Firefox. Unless you choose a custom installation, you can prevent these changes on your browser.

Although the application user interface is so simple and less attractive, but its function is quite good. In the main window there is a list of “encryption algorithms” which is quite interesting. You can select AES (128/192/256-bit) RC2/4/5/6, DES and Triple DES, Blowfish, Twofish, Serpent, Camellia, Skipjack, CAST-256, MARS, IDEA, SEED, GOST, XTEA, and SHACAL-2.

VSEncryptor can use these algorithms to randomize the plain text and other types of files. As soon as you press the encryption button, this app will ask you to enter a password that will also be used to decrypt the data.

It does not take long to encrypt the plain text, as well as encrypting other types of files. To file size of about 20 MB, it only takes a few seconds. Encrypt speed also depends on the chosen algorithm. By default, the encryption result is stored in the same location as the original file, but we also can change it as you wish.

By default again, VSEncryptor add a new file extension that is <. Encrypted> for encrypted items. The same option is also available to decrypt the file, only the extension form <. Decrypted>.

Internet Wars: Chrome overtakes Internet Explorer & Samsung beats Apple to mobile top-spot

Website analytics company StatCounter have revealed its latest report covering global trends of internet access and software popularity. Dubbed ‘Internet Wars’ the report contains two major power shifts: in terms of mobile internet access Samsung has overtaken Apple whilst Chrome have has stolen Internet Explorer’s browser crown. See below for a full break-down of the report:

Mobile: Samsung & Chrome lead the way

In terms of mobile vendors the changes have been somewhat expected. 12 months ago Nokia was the number one vendor for connecting to mobile internet but they’ve now dropped to third place as Samsung overtakes Apple by a small margin.

In terms of mobile browser usage the global market shows Android’s default browser out in front with 29% compared to Safari’s 25%; but in the US and the UK the Apple products are clear leaders – taking 55% and 48% of the market share respectively.

This is a direct reflection of mobile OS trends where Android are ahead globally (38%, up from 26% last year) but with the US and the UK showing a pretty clear preference for the iOS. In the US Apple takes 55% and Android 39%; in the UK Apple gets 48% and Android has 30%. The UK also proves to be a bit of a hold-out for Blackberry – holding on to a respectable 15% of the market.

Browsers & Operating Systems: Internet Explorer beaten, but Windows remains dominant

The browser wars have seen Google overtake Microsoft’s Internet Explorer for the first time in June this year, with Firefox and Safari taking third and fourth place respectively. Chrome took 34% of the market, compared to IE’s 32%.

StatCounter’s report also took in the balance of power with operating systems, showing Windows 7 actually increasing its internet usage share to 51% despite the fanfare-launch of Windows 8. And 12 years after its launch, Windows XP is still hanging in there with 21% of the global market, comfortably above Apple’s consistent third-place OSX (over 7% share).

In the UK specifically Windows 7 still keeps its top-spot with a 49% market share, but – unlike in the global market – Mac’s OSX takes second place with 11%, beating out Windows XP’s 10% share.

It was also revealed that despite reports of Facebook’s declining appeal amongst teenagers the site has still managed to increase its market share – at least in terms of referall traffic, the metric that StatCounter uses.

Social media: Facebook still king, though UK has a soft spot for Twitter

Worlwide Facebook has increased its referral influence from 61% in June 2012 to 71% in June 2013. Other social networks still barely register on this scale – with StumbleUpon falling from 9% to 5%, Pinterest taking the number two slot with 8% and Twitter taking up third place with 7%.

In the US Pinterest had a far more dominant position, climbing to a healthy second place in terms of referral traffic with 22% of the market share compared to Facebook’s 52%; whilst in the UK it was Twitter that took the number two spot, with 16% of referral traffic compared to Facebook’s 62%.

However, it should be noted that referral traffic – whilst a useful metric – is by no means the be all and end all of social media influence.

A recent essay by Ethan Zuckerman for the Atlantic pointed out that whilst Facebook may dominate in terms of user figures, the influence it create tends to be fairly insular – with links spread amongst individuals that are already friends. Zuckerman counterpoints this with Reddit – which is far less popular in terms of actual user figures but might be considered more influential as it manages to  spread content amongst strangers, reaching further flung areas of the web.

HTC Unveils Rival Mini Galaxy S4

Ghiboo.com – HTC finally officially introduced its latest smartphone which is a mini series of HTC.

Quoted from Techradar, Friday (19/7), it is clearly seen that the presence of HTC Mini is to become a major competitor Samsung Galaxy S4 Mini.

With frills ‘Mini’, of course, HTC offers a size and a smaller screen than the original version. In addition, some hardware also decreased.

HTC Mini armed with a 4.3-inch 720p display with overall body dimensions are 132×63, 2×9, 25mm and weighing 122gram. The processor used is a dual-core 1.4GHz with 1GB RAM and support for 16GB of internal memory.

Ultrapixel camera still be the main dish, which fortunately, had equivalent quality original HTC. The Taiwanese manufacturers rely on the operating system of Android 4.2.2 Jelly Bean, plus the HTC Sense UI and Blinkfeed are also provided.

There is no information about when the HTC One Mini will be released to the market, as well as about the price. To be sure, if you really want to compete directly with the Galaxy S4 Mini, of course, the price offered will not differ much.

Stopping Google Latitude Service on August 9th

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

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

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

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

HP Series 600 G1 ProOne Simplify Daily Fulfillment

JAKARTA – HP Series ProOne ProDesk 600 600 G1 and G1 show business for AiO devices and desktop PCs with the latest design and latest selection of 4th generation Intel Core processor at an affordable price.
Each device allows the user to easily meet daily business needs with a choice of Windows 8, Windows 7, HP Device Support Assistant, HP Client Security applications and strong to protect the data, device and identity.
Increased productivity with HP ePrint for quick and easy wireless printing, as well as DTS Sound for rich audio sound.
ProOne HP AiO 600 G1 is the enterprise-class has a space-saving design with powerful PC performance and secure.
HP ProDesk G1 600 series offers the most popular form factor with the availability of a stable cycle of up to 30 months and to meet everyday business needs with performance and reliability.
Multitasking helped with the choice of storage solutions solid-state drive that makes files and applications together quickly.