JAKARTA – Not only unique, Logitech ® Wireless Mouse M235 Limited Edition is fairly advanced. Because the mouse has been equipped with a Logitech ® Advanced Optical Tracking that can work in almost any kind of surface.
Connectivity Logitech Advanced 2.4 GHz wireless gives you the freedom to faster data transmission and no lag or connection is lost.
This advanced wireless mouse connected via nano-receiver is so small sturdy nan, you simply connect it to the USB port and then forget about it. Product contoured and comfortable in the hand, with rubber grip and scroll whell to scroll naturally.
Logitech ® Wireless Mouse M235 is equipped with On / Off button and an intelligent sleep mode, to help you to conserve battery power, so the battery can last up to 1 year, depending on usage patterns and computing conditions.
Logitech ® Wireless Mouse M235 Limited Edition has been available in the Indonesian market with a retail price of USD 19.99 or approximately USD 190 thousand.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


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.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


JAKARTA – Not to be outdone in the battle gadgets in the year 2013, Hewlett Packard (HP) introduced a series of new products by collaborating with Intel as a supplier of processors. The product line consists of a convertible tablet, the PC Desktop and all in one ones (AIOS), as well as commercial notebook like the HP Elitebook Revolve 850, HP Probook 440, Probook 430, 800 Elitedesk G1, EliteOne 800 G1, G1 and ProDesk 800 HP ProOne 600 G1.

Managing Director of HP Indonesia, Subin Joseph said that these products have been designed specifically for job flexibility. According to him, the range of products it can provide maximum efficiency in terms of creativity, access and enjoy content.

Joseph added all of the line, either desktop or notebook has led HP into higher stages. “Everything we present the latest design and tough. Has automatic sensors to turn off the hard drive in as it fell, so safe,” he said at the launch of HP’s new products at the Intercontinental Hotel Jakarta, Wednesday (24/7).

HP’s latest product line is equipped with a processor Intel Core 4th generation. “Best performance, security and responsive performance so we present one in the device and is suitable for all computing lifestyle,” explains Head of MNC Sales Intel Indonesia, Yohan Wijaya.

Yohan further explained, the latest-generation Intel Core PC coupled with a stunning performance with mobility like a tablet. “Its performance is 15 percent better than its predecessor. Latest processor can spoil the user ranging from the battery life to a remarkable breakthrough in terms of graphics,” Yohan lid.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


Introduction

Qt Quick’s QML language makes it easy to do many things, especially fancy animated user interfaces. However, some things either can’t be done or are not suitable for implementing in QML, such as:

  1. Getting access to functionality outside of the QML/JavaScript environment.
  2. Implementing performance critical functions where native code is desired for efficiency.
  3. Large and/or complex non-declarative code that would be tedious to implement in JavaScript.

As we’ll see, Qt makes it quite easy to expose C++ code to QML. In this blog post I will show an example of doing this with a small but functional application.

The example is written for Qt 5 and uses the Qt Quick Components so you will need at least Qt version 5.1.0 to run it.

Overview

To expose a C++ type having properties, methods, signals, and/or slots to the QML environment, the basic steps are:

  1. Define a new class derived from QObject.
  2. Put the Q_OBJECT macro in the class declaration to support signals and slots and other services of the Qt meta-object system.
  3. Declare any properties using the Q_PROPERTY macro.
  4. Call qmlRegisterType() in your C++ main program to register the type with the Qt Quick engine.

For all the details I refer you to the Qt documentation section Exposing Attributes of C++ Types to QML and the Writing QML Extensions with C++ tutorial.

Ssh Key Generator

For our code example, we want a small application that will generate ssh public/private key pairs using a GUI. It will present the user with controls for the appropriate options and then run the program ssh-keygen to generate the key pair.

I implemented the user interface using the new Qt Quick Controls since it was intended as a desktop application with a desktop look and feel. I initially developed the UX entirely by running the qmlscene program directly on the QML source.

The UI prompts the user for the key type, the file name of the private key to generate and an optional pass phrase, which needs to be confirmed.

The C++ Class

Now that have the UI, we will want to implement the back end functionality. You can’t invoke an external program directly from QML so we have to write it in C++ (which is the whole point of this example application).

First, we define a class that encapsulates the key generation functionality. It will be exposed as a new class KeyGenerator in QML. This is done in the header file KeyGenerator.h below.

#ifndef KEYGENERATOR_H
#define KEYGENERATOR_H

#include <QObject>
#include <QString>
#include <QStringList>

// Simple QML object to generate SSH key pairs by calling ssh-keygen.

class KeyGenerator : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString type READ type WRITE setType NOTIFY typeChanged)
    Q_PROPERTY(QStringList types READ types NOTIFY typesChanged)
    Q_PROPERTY(QString filename READ filename WRITE setFilename NOTIFY filenameChanged)
    Q_PROPERTY(QString passphrase READ filename WRITE setPassphrase NOTIFY passphraseChanged)

public:
    KeyGenerator();
    ~KeyGenerator();

    QString type();
    void setType(const QString &t);

    QStringList types();

    QString filename();
    void setFilename(const QString &f);

    QString passphrase();
    void setPassphrase(const QString &p);

public slots:
    void generateKey();

signals:
    void typeChanged();
    void typesChanged();
    void filenameChanged();
    void passphraseChanged();
    void keyGenerated(bool success);

private:
    QString _type;
    QString _filename;
    QString _passphrase;
    QStringList _types;
};
#endif

Next, we need to derive our class from QObject. We declare any properties that we want and the associated methods. Notify methods become signals. In our case, we want to have properties for the selected key type, the list of all valid ssh key types, file name and pass phrase. I arbitrarily made the key type a string. It could have been an enumerated type but it would have made the example more complicated.

Incidentally, a new feature of the Q_PROPERTY macro in Qt 5.1.0 is the MEMBER argument. It allows specifying a class member variable that will be bound to a property without the need to implement the setter or getter functions. That feature was not used here.

We declare methods for the setters and getters and for signals. We also declare one slot called generateKey(). These will all be available to QML. If we wanted to export a regular method to QML, we could mark it with Q_INVOCABLE. In this case I decided to make generateKey() a slot since it might be useful in the future but it could have just as easily been an invocable method.

Finally, we declare any private member variables we will need.

C++ Implementation

Now let’s look at the implementation in KeyGenerator.cpp. Here is the source code:

#include <QFile>
#include <QProcess>
#include "KeyGenerator.h"

KeyGenerator::KeyGenerator()
    : _type("rsa"), _types{"dsa", "ecdsa", "rsa", "rsa1"}
{
}

KeyGenerator::~KeyGenerator()
{
}

QString KeyGenerator::type()
{
    return _type;
}

void KeyGenerator::setType(const QString &t)
{
    // Check for valid type.
    if (!_types.contains(t))
        return;

    if (t != _type) {
        _type = t;
        emit typeChanged();
    }
}

QStringList KeyGenerator::types()
{
    return _types;
}

QString KeyGenerator::filename()
{
    return _filename;
}

void KeyGenerator::setFilename(const QString &f)
{
    if (f != _filename) {
        _filename = f;
        emit filenameChanged();
    }
}

QString KeyGenerator::passphrase()
{
    return _passphrase;
}

void KeyGenerator::setPassphrase(const QString &p)
{
    if (p != _passphrase) {
        _passphrase = p;
        emit passphraseChanged();
    }
}

void KeyGenerator::generateKey()
{
    // Sanity check on arguments
    if (_type.isEmpty() or _filename.isEmpty() or
        (_passphrase.length() > 0 and _passphrase.length() < 5)) {
        emit keyGenerated(false);
        return;
    }

    // Remove key file if it already exists
    if (QFile::exists(_filename)) {
        QFile::remove(_filename);
    }

    // Execute ssh-keygen -t type -N passphrase -f keyfileq
    QProcess *proc = new QProcess;
    QString prog = "ssh-keygen";
    QStringList args{"-t", _type, "-N", _passphrase, "-f", _filename};
    proc->start(prog, args);
    proc->waitForFinished();
    emit keyGenerated(proc->exitCode() == 0);
    delete proc;
}

The constructor initializes some of the member variables. For fun, I used the new initializer list feature of C++11 to initialize the _types member variable which is of type QStringList. The destructor does nothing, at least for now, but is there for completeness and future expansion.

Getter functions like type() simply return the appropriate private member variable. Setters set the appropriate variables, taking care to check that the new value is different from the old one and if so, emitting the appropriate signal. As always, please note that signals are created by the Meta Object Compiler and do not need to be implemented, only emitted at the appropriate times.

The only non-trivial method is the slot generateKey(). It does some checking of arguments and then creates a QProcess to run the external ssh-keygen program. For simplicity and because it typically executes quickly, I do this synchronously and block on it to complete. When done, we emit a signal that has a boolean argument that indicates the key was generated and whether it succeeded or not.

QML Code

Now let’s look at the QML code in main.qml:

// SSH key generator UI

import QtQuick 2.1
import QtQuick.Controls 1.0
import QtQuick.Layouts 1.0
import QtQuick.Dialogs 1.0
import com.ics.demo 1.0

ApplicationWindow {
    title: qsTr("SSH Key Generator")

    statusBar: StatusBar {
    RowLayout {
        Label {
            id: status
            }
        }
    }

    width: 369
    height: 166

    ColumnLayout {
        x: 10
        y: 10

        // Key type
        RowLayout {
            Label {
                text: qsTr("Key type:")
            }
            ComboBox {
                id: combobox
                Layout.fillWidth: true
                model: keygen.types
                currentIndex: 2
            }
        }

        // Filename
        RowLayout {
            Label {
                text: qsTr("Filename:")
            }
            TextField {
                id: filename
                implicitWidth: 200
                onTextChanged: updateStatusBar()
            }
            Button {
                text: qsTr("&Browse...")
                onClicked: filedialog.visible = true
            }
        }

        // Passphrase
        RowLayout {
            Label {
                text: qsTr("Pass phrase:")
            }
            TextField {
                id: passphrase
                Layout.fillWidth: true
                echoMode: TextInput.Password
                onTextChanged: updateStatusBar()
            }

        }

        // Confirm Passphrase
        RowLayout {
            Label {
                text: qsTr("Confirm pass phrase:")
            }
            TextField {
                id: confirm
                Layout.fillWidth: true
                echoMode: TextInput.Password
                onTextChanged: updateStatusBar()
            }
        }

        // Buttons: Generate, Quit
        RowLayout {
            Button {
                id: generate
                text: qsTr("&Generate")
                onClicked: keygen.generateKey()
            }
            Button {
                text: qsTr("&Quit")
                onClicked: Qt.quit()
            }
        }

    }

    FileDialog {
        id: filedialog
        title: qsTr("Select a file")
        selectMultiple: false
        selectFolder: false
        nameFilters: 
        selectedNameFilter: "All files (*)"
        onAccepted: {
            filename.text = fileUrl.toString().replace("file://", "")
        }
    }

    KeyGenerator {
        id: keygen
        filename: filename.text
        passphrase: passphrase.text
        type: combobox.currentText
        onKeyGenerated: {
            if (success) {
                status.text = qsTr('<font color="green">Key generation succeeded.</font>')
            } else {
                status.text = qsTr('<font color="red">Key generation failed</font>')
            }
        }
    }

    function updateStatusBar() {
        if (passphrase.text != confirm.text) {
            status.text = qsTr('<font color="red">Pass phrase does not match.</font>')
            generate.enabled = false
        } else if (passphrase.text.length > 0 && passphrase.text.length < 5) {
            status.text = qsTr('<font color="red">Pass phrase too short.</font>')
            generate.enabled = false
        } else if (filename.text == "") {
            status.text = qsTr('<font color="red">Enter a filename.</font>')
            generate.enabled = false
        } else {
            status.text = ""
            generate.enabled = true
        }
    }

    Component.onCompleted: updateStatusBar()
}

The preceding code is a little long, however, much of the work is laying out the GUI components. The code should be straightforward to follow.

Note that we import com.ics.demo version 1.0. We’ll see where this module name comes from shortly. This makes a new QML type KeyGeneratoravailable and so we declare one. We have access to it’s C++ properties as QML properties, can call it’s methods and act on signals like we do withonKeyGenerated.

A more complete program should probably do a little more error checking and report meaningful error messages if key generation fails (we could easily add a new method or property for this). The UI layout could also be improved to make it properly resizable.

Our main program is essentially a wrapper like qmlscene. All we need to do to register our type with the QML engine is to call:

    qmlRegisterType<KeyGenerator>("com.ics.demo", 1, 0, "KeyGenerator");

This makes the C++ type KeyGenerator available as the QML type KeyGenerator in the module com.ics.demo version 1.0 when it is imported.

Typically, to run QML code from an executable, in the main program you would create a QGuiApplication and a QQuickView. Currently, to use the Qt Quick Components there is some additional work needed if the top level element is an ApplicationWindow or Window. You can look at the source code to see how I implemented this. I basically stripped down the code from qmlscene to the minimum of what was needed for this example.

Here is the full listing for the main program, main.cpp:

#include <QApplication>
#include <QObject>
#include <QQmlComponent>
#include <QQmlEngine>
#include <QQuickWindow>
#include <QSurfaceFormat>
#include "KeyGenerator.h"

// Main wrapper program.
// Special handling is needed when using Qt Quick Controls for the top window.
// The code here is based on what qmlscene does.

int main(int argc, char ** argv)
{
    QApplication app(argc, argv);

    // Register our component type with QML.
    qmlRegisterType<KeyGenerator>("com.ics.demo", 1, 0, "KeyGenerator");

    int rc = 0;

    QQmlEngine engine;
    QQmlComponent *component = new QQmlComponent(&engine);

    QObject::connect(&engine, SIGNAL(quit()), QCoreApplication::instance(), SLOT(quit()));

    component->loadUrl(QUrl("main.qml"));

    if (!component->isReady() ) {
        qWarning("%s", qPrintable(component->errorString()));
        return -1;
    }

    QObject *topLevel = component->create();
    QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);

    QSurfaceFormat surfaceFormat = window->requestedFormat();
    window->setFormat(surfaceFormat);
    window->show();

    rc = app.exec();

    delete component;
    return rc;
}

In case it is not obvious, when using a module written in C++ with QML you cannot use the qmlscene program to execute your QML code because the C++ code for the module will not be linked in. If you try to do this you will get an error message that the module is not installed.

CATEGORIES : Computer Technology, Programming/ AUTHOR : besteckverleih/ 0 Comment


JAKARTA – Toshiba continues to flood the market with the latest line of notebooks. Unmitigated, the Japanese manufacturer is introducing six champion as well as to the Indonesian market.
Toshiba seems to deliberately give broad options to consumers on the need for a portable PC. Six new hero is introduced, among others, Z10t Portege, Qosmio X70, S40 Satellite, Satellite P50, Satellite C40, and Satellite L40.
“Purity, Metal, Functional Elegance, Intuition, and Technology. Those are some basic designs that we apply to our newest line of laptops,” said Gregory Beh, Product Specialist, PC Product Marketing, Computer Systems Division, Toshiba Singapore, in Introducing New Toshiba Notebook PC’s Line Up, in Jakarta, Thursday (07/04/2013).
He added that the six portable PC is Toshiba’s line up of products that are available in the market this month. “This year we are still concentrating on notebooks,” said Beh.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


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

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

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

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

Audience

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

How to Read This Book

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

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

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

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

CATEGORIES : Computer Technology, Programming/ AUTHOR : besteckverleih/ 0 Comment


Compete with Extra Ability

Lapse of more than half a year since the launch of the One X is quite a success, then give refreshment and HTC launched the One X + (plus). With increasing processor speeds and provide extra capacity storage media and batteries, this series is expected to remain competitive amid the onslaught of newer-generation smartphone.

u5-435-HTCKonstruksi HTC One X + is still the same as the previous series that uses materials that are designed in the form of polycarbonate unibody. Design which has the characteristics of this matte than more resistant to fingerprints, it also provides a more stable grip. The face is still protected by Gorilla Glass. The difference, he had to use the second generation of the tough glass. In general, no different from the appearance of the HTC One X and HTC One X +.

Because of the similarity of physical appearance as well, screen HTC One X + also still uses Super IPS LCD2 with a diagonal size of 4.7 _ and a resolution of 720 × 1280 pixels. PCplus still like the quality of the display screen is a slick, well-balanced color saturation, and brightness levels are adequate, especially when used in the sun. One thing that is steady on the screen HTC One X + is a point of view that could be considered extraordinary. Even at extreme angles, especially the color display looks as if no change / fade at all.

The main focus of the HTC One X + is increased in order to support some important aspects of its overall performance. First, Nvidia Tegra 3 SoC that is used to work faster at 1.7 GHz: 200 MHz faster than its predecessor series. Second, a 64GB media capacity shelf, making it very relieved to save anything. Last but not least is a plus 300mAh battery capacity 2100mAh so so.

Any of the software, HTC One X + is equipped with Jelly Bean Android 4.1.1 and Sense UI 4 +. Although the display is still the same, but the Sense UI 4 + is already avail-owned Butter Jelly Bean Project. This combination makes the HTC One X + runs very smoothly, especially navigating between menus. What is interesting, because it’s UI design, features Google Now owned by Jelly Bean is quite hidden. The trick is to press and hold the Home button for a few seconds, came the new assistant feature the Android smart style.

If the previous HTC One X is an upscale line of smartphones, the series “plus” is easily dethrone the predecessor position.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


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.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment


Adobe Digital Marketing Forum — Adobe Systems Incorporated (ADBE) today announced the availability of the all-new Adobe® Social, which now features integration with Flickr, Foursquare, Instagram and LinkedIn, in addition to social predictive publishing capabilities, a mobile user interface, streamlined reporting, and new collaborative features. Adobe Social is the first solution specifically designed to leverage the new Adobe Marketing Cloud interface, which enables on-the-go marketing capabilities from any device. Adobe Social, a key element of Adobe Marketing Cloud, enables marketers to scale social marketing across their organizations, listen and respond to customer conversations, and connect the dots between social interactions and business results.

“Today’s social marketers are challenged to validate their social spend,” said Bill Ingram, vice president of product management, Digital Marketing, Adobe. “Adobe Social makes it easy to measure business impact from social campaigns and use that data to optimize strategy in a highly visual format.”

New Social Platforms Supported

On a daily basis, social marketers attempt to listen to the vast amounts of available social data, use that data to publish compelling content and then create better digital experiences for their audience. At the same time, they look to foster two-way conversations with customers and prospects to nurture these relationships. And they need to do all of this across an ever-growing number of social platforms.

With that in mind, Adobe Social is now integrated with Flickr, Foursquare and Instagram, which complement existing integrations with Facebook, Google+, Reddit, Tumblr, Twitter, YouTube and many more to offer the most comprehensive understanding of social conversations, consumer behavior, and real-time trends. The addition of Foursquare is unique as Adobe Social is the first to capitalize on the social network’s exclusive partnership with leading data provider, Gnip, to leverage the full fire hose of Foursquare’s check-in data. Access to local-mobile data will help social marketers understand the movement in customer check-ins, the competitive landscape, and how localized marketing initiatives align with specific venue check-in data.

Adobe Social is also adding the ability to publish content to and analyze metrics associated with LinkedIn Company Pages and Groups, features that will support relationship-building on this critical professional network. The addition of these new platforms increases Adobe’s consumer touch-points, enabling social marketers to scale across the enterprise and build a more complete understanding of the consumer.

“Adobe Social is enabling Mastercard to seamlessly engage with local markets around the world, building trust through online listening, conversation and community,” said Adam Broitman, vice president, Global Digital Marketing, Mastercard. “Now that’s priceless.”

Predictive Publishing Predicts Social Content Performance

Adobe also made available today a powerful new predictive publishing capability for Adobe® Social, which predicts social engagement on individual pieces of content and automatically suggests ideal timing to improve how that content will perform. The new predictive publishing feature in Adobe Social helps social teams deliver content that will best resonate with their audience. And because the solution learns as it goes, it continually refines recommendations and gets smarter with each action.

New Adobe Marketing Cloud Interface

Utilizing the new unified Adobe Marketing Cloud interface, now available for Adobe Social, marketers and their teams can now surface valuable insights and collaborate more effectively. This collaboration extends not only across their own company but across distributed external teams as well—improving workflows, streamlining marketing activities, and maximizing ROI. With the new single sign-on feature, customers can directly access Adobe Marketing Cloud solutions from within one unified interface, and the new social feed will deliver relevant internal content and insights shareable across Adobe Marketing Cloud solutions.

CATEGORIES : Computer Technology, Software/ AUTHOR : besteckverleih/ 0 Comment


After a long awaited, Google finally released the latest Android operating system version 4.3, which still carries the code name Jelly Bean, Wednesday (07/24/2013). Android 4.3 comes with several new features.

As quoted from The Verge, Google adds multi-user settings in Android 4.3. It is useful to restrict the use and application of a profile feature.

Director of Product Management at Android, Hugo Barra explained, parents can set their children can not open content not suitable for children.

Additionally, Google adds Bluetooth Smart claimed could save battery consumption. Android 4.3 also supports OpenGL ES 3.0 that improves the quality of the graphics for gaming, including 3D.

Starting today, Android 4.3 can be downloaded over-the-air by the users of the Samsung Galaxy Nexus, LG Nexus 4, Nexus 7 Asus tablet is also the first generation and Samsung Nexus 10.

CATEGORIES : Computer Technology, Hardware/ AUTHOR : besteckverleih/ 0 Comment