Thursday, June 9, 2016

Get paid by your US and EU clients with Payoneer

payoneer-logoBig love to Payoneer – this weeks RSS feed and website sponsor.

Payoneer is a financial service that allows you to get paid by companies and clients in the US, EU, UK, and Japan.

The beauty of it really is you get given this Mastercard that pretty much works anywhere in the world. This is especially useful if you live and freelance in a remote country. So when on your next holiday you can swipe or withdraw from your Payoneer Mastercard flawlessly. Awesome:)

Can I transfer the money to my local bank account?

Absolutely! You can also withdraw money to your local bank account if you wish, at any time.

“I can honestly say that Payoneer has changed my life! My biggest problem has been solved, and now I can withdraw money that I received online through the US Payment Service, without having to incur in any expenses, like depositing money to open such an account.” ~ Eduardo Grude, Co-Founder, Grudeweb, LLC, Venezuela

The real beauty of the service is that they provide US, EU, UK, and Japanese companies with legitimate bank account details on your behalf. They pay into that account and the money is transferred to your Payoneer online balance.

Excellent but what are the fees?!

The convenience is really priceless but of course there need to be fees to make it all sustainable. The cost per year is $29 to use Payoneer BUT remember if your account balance is $0 then there are no fees. Good to know.

To swipe your card anywhere in the world is free! There is a 3% foreign transaction fee when transaction is made in a different currency.

To withdraw at an ATM in the US is $1.75 per withdrawal and $3.15 outside the US.

Sign up with Payoneer now and get a $25 Bonus

If you signup with this link, once you have received your first $100 through the service, Payoneer Mastercard will give you an additional $25 as a thank you.


by Rob Hope via One Page Love

BackFlip : jQuery Dynamic Background Colors Changer Plugin

A jQuery plugin that allows you to dynamically change the background colors of a container or div with a couple lines of code.

The post BackFlip : jQuery Dynamic Background Colors Changer Plugin appeared first on jQuery Rain.


by Admin via jQuery Rain

CSS Vertical Navigation with Teaser

This article explains how to create vertical navigation menus without jquery or javascript. Yes, we are going to build vertical menus with CSS only. The navigation menu of a website plays a significant role in website’s usability and User Experience. Without menu navigation site is like content all but useless.

The post CSS Vertical Navigation with Teaser appeared first on jQuery Rain.


by Admin via jQuery Rain

Wednesday, June 8, 2016

Conversational UIs, R2-D2 and Avoiding the Uncanny Valley

What was the first 'killer phone app'? I'm talking about first non-voice offering that had droves of people buying mobile phones for the first time just to use it?

Was it Google Maps? Maybe the YouTube app? Bejewelled? Facebook?

No - as important as they were, I think the original killer app has to be SMS (or texting). Sending little notes to each other doesn't sound very innovative or exciting, but from the early 90's onwards, SMS drove the adoption of cellphones and provided an obscenely lucrative revenue stream to phone network providers.

People seemed to like SMS for three reasons.

  1. It was private
  2. It was simple
  3. It felt familiar

We all probably passed notes in class and stuck them on the refrigerator door. SMS just let us pass them across the world.

Many of the first big online services for desktop computers used the same chatty approach - ICQ, Yahoo IM, AIM, and MSN Messenger.

Even today Facebook Messenger, Whatsapp Twitter, and Slack have billions of users every day tapping out short text messages to each other.

What can we say? Humans really like this format.

Birth of the Conversational User Interface

The last two years have seen the rise of a new kind of user interface. Slack were one of the first companies to realize that this 'human-to-human' chat format might work just as well for human-to-app interactions.

Instead of using a standard account creation sign-up form, Slack used their 'Slackbot' like a welcoming hotel concierge.

Slackbot sign-up

And it made so much sense. They want you to chat - why not start chatting from the first moments you use the app? The idea has been reproduced many times since.

Quartz: Chatty News App

Quartz is a new news app (currently iOS only) that takes the idea of conversational UIs to a new level.

While Slack was a chat client just expanding where it chatted, Quartz jams news events into an SMS-like format. It's a bit like having a friend SMSing you newspaper snippets to read on the train. You can ask your friend for more detail on the story or tell them to move on.

Quartz in action

While I'm not totally convinced yet that Quartz is a winner, it is a brilliantly original way to think about presenting news. It's loose and informal and easily the most clutter-free news UI you've ever seen. Each time you read a new message and make a yes/no decision - Quartz handles the rest. Interesting.

One interesting little UI touch is the 'typing' indicator that appears just before Quartz posts a new message to screen – three drumming dots inside a speech bubble (see the animation below).

We're all familiar with this idea. In real world conversations, we can signal with body language that we're about to speak. In chat apps from ICQ in 1996 to Slack today, we get a visual indicator that the other person is in the act of replying. It's a useful protocol.

But this is an app speaking to us - not a friend or colleague.

Quartz Conversational UI

Now let's be frank: We all implicitly understand that this is all 'UX theater' for our benefit. Even my 10-yo daughter immediately picked it. There's nobody banging away at a real keyboard.

So, how do we feel about that?

I'm not sure about you, but I've been surprised by my own gut reaction. My designer brain tells me I should be dismissive and snarky. "Bah! How dare you slow down my experience with such feeble parlor tricks!" (yes, my designer brain sounds like Professor Moriarty)

But my UX-self started grudgingly liking it - and I couldn't understand why at first.

Continue reading %Conversational UIs, R2-D2 and Avoiding the Uncanny Valley%


by Alex Walker via SitePoint

How to Use LinkedIn to Connect With Your Ideal Customers [INFOGRAPHIC]

How to Use LinkedIn to Connect With Your Ideal Customers [INFOGRAPHIC]

“When it comes to the professional side of social media, LinkedIn is still the top network. Whether you are in a B2B or B2C business, LinkedIn is the perfect platform to get to know and engage with your customers.

Why? LinkedIn is strictly used for business, which means when people sign in, they are not thinking about Farmville, baby pictures, or catching up on what their friends are doing.”

The below infographic, created by Salesforce, illustrates how LinkedIn can help you to reach your ideal customers.

by Irfan Ahmad via Digital Information World

Jump Start Git: Branching in Git

jsgit

The following is a short extract from our book, Jump Start Git, available for free to SitePoint Premium members. Print copies are sold in stores worldwide, or you can order them here. We hope you enjoy this extract and find it useful.

In Chapter 1, I talked about my one-time fear of trying out new things in a project. What if I tried something ambitious and it broke everything that was working earlier? This problem is solved by the use of branches in Git.

What Are Branches?

Creating a new branch in a project essentially means creating a new copy of that project. You can experiment with this copy without affecting the original. So if the experiment fails, you can just abandon it and return to the original—the master branch.

But if the experiment is successful, Git makes it easy to incorporate the experimental elements into the master. And if, at a later stage, you change your mind, you can easily revert back to the state of the project before this merger.

So a branch in Git is an independent path of development. You can create new commits in a branch while not affecting other branches. This ease of working with branches is one of the best features of Git. (Although other version control options like CVS had this branching option, the experience of merging branches on CVS was a very tedious one. If you've had experience with branches in other version control systems, be assured that working with branches in Git is quite different.)

In Git, you find yourself in the master branch by default. The name “master” doesn't imply that it's superior in any way. It's just the convention to call it that.

Note: Branch Conventions

Although you're free to use a different branch as your base branch in Git, people usually expect to find the latest, up-to-date code on a particular project in the master branch.

You might argue that, with the ability to go back to any commit, there's no need for branches. However, imagine a situation where you need to show your work to your superior, while also working on a new, cool feature which is not a part of your completed work. As branching is used to separate different ideas, it makes the code in your repository easy to understand. Further, branching enables you to keep only the important commits in the master branch or the main branch.

Yet another use of branches is that they give you the ability to work on multiple things at the same time, without them interfering with each other. Let's say you submit feature 1 for review, but your supervisor needs some time before reviewing it. Meanwhile, you need to work on feature 2. In this scenario, branches come into play. If you work on your new idea on a separate branch, you can always switch back to your earlier branch to return the repository to its previous state, which does not contain any code related to your idea.

Let's now start working with branches in Git. To see the list of branches and the current branch you're working on, run the following command:

[code language="bash"]git branch
[/code]

If you have cloned your repository or set a remote, you can see the remote branches too. Just postfix -a to the command above:

[code language="bash"]git branch -a
[/code]
[caption id="attachment_131959" align="alignnone" width="264"]Command showing the branches in the local copy as well as the origin branch Command showing the branches in the local copy as well as the origin branch[/caption]

As shown above, the branches that colored red signify that they are on a remote. In our case, we can see the various branches that are present in the origin remote.

Create a Branch

There are various ways of creating a branch in Git. To create a new branch and stay in your current branch, run the following:

[code language="bash"]git branch test_branch
[/code]

Here, test_branch is the name of the created branch. However, on running git branch, it seems that the active branch is still the master branch. To change the active branch, we can run the checkout command (shown below):

[code language="bash"]git checkout test_branch
[/code]
[caption id="attachment_131988" align="alignnone" width="300"]Creating a new branch and making it active Creating a new branch and making it active[/caption]

You can also combine the two commands above and thereby create and checkout to a new branch in a single command by postfixing -b to the checkout command:

[code language="bash"]git checkout -b new_test_branch
[/code]
Create and checkout to a new branch in a single command

The branches we've just created are based on the latest commit of the current active branch—which in our case is master. If you want to create a branch (say old_commit_branch) based on a certain commit—such as cafb55d—you can run the following command:

[code language="bash"]git checkout -b old_commit_branch cafb55d
[/code]

[caption id="attachment_131995" align="alignnone" width="575"]Creating a branch based on an old commit Creating a branch based on an old commit[/caption]

To rename the current branch to renamed_branch, run the following command:

[code language="bash"]git branch -m renamed_branch
[/code]

Delete a Branch

To delete a branch, run the following command:

[code language="bash"]git branch -D new_test_branch
[/code]

[caption id="attachment_131996" align="alignnone" width="300"]Deleting a branch in Git Deleting a branch in Git[/caption]

Note: Don't Delete Branches Unless You Have To

As there's not really any downside to keeping branches, as a precaution I'd suggest not deleting them unless the number of branches in the repository becomes too large to be manageable.

The -D option used above deletes a branch even if it hasn't been synchronized with a remote branch. This means that if you have commits in your current branch that have not been pushed yet, -D will still delete your branch without providing any warning. To ensure you don't lose data, you can postfix -d as an alternative to -D. -d only deletes a branch if it has been synchronized with a remote branch. Since our branches haven't been synced yet, let's see what happens if we postfix -d, shown below:

Deleting a branch in Git using the -d option

As you can see, Git gives you a warning and aborts the operation, as the data hasn't been merged with a branch yet.

Branches and HEAD

Now that we've had a chance to experiment with the basics of branching, let's spend a little time discussing how branches work in Git, and also introduce an important concept: HEAD.

As mentioned above, a branch is just a link between different commits, or a pathway through the commits. An important thing to note is that, while working with branches, the HEAD of a branch points to the latest commit in the branch. I'll refer to HEAD a lot in upcoming chapters. In Git, the HEAD points to the latest commit in a branch. In other words, it refers to the tip of a branch.

A branch is essentially a pointer to a commit, which has a parent commit, a grandparent commit, and so on. This chain of commits forms the pathway I mentioned above. How, then, do you link a branch and HEAD? Well, HEAD and the tip of the current branch point to the same commit. Let's look at a diagram to illustrate this idea:

[caption id="attachment_132000" align="alignnone" width="609"]Branches and HEAD Branches and HEAD[/caption]

As shown above, branch_A initially is the active branch and HEAD points to commit C. Commit A is the base commit and doesn't have any parent commit, so the commits in branch_A in reverse chronological order (which also forms the pathway I've talked about) are C → B → A. The commits in branch_B are E → D → B → A. The HEAD points to the latest commit of the active branch_A, which is commit C. When we add a commit, it's added to the active branch. After the commit, branch_A points to F, and the branch follows F → C → B → A, whereas branch_B remains the same. HEAD now points to commit F. Similarly, the changes when we add yet another commit are demonstrated in the figure.

Advanced Branching: Merging Branches

As mentioned earlier, one of Git's biggest advantages is that merging branches is especially easy. Let's now look at how it's done.

We'll create two new branches—new_feature and another_feature—and add a few dummy commits. Checking the history in each branch shows us that the branch another_feature is ahead by one commit, as shown below:

[caption id="attachment_132001" align="alignnone" width="546"]Checking the history in each branch Checking the history in each branch[/caption]

This situation can be visualized as shown below. Each circle represents a commit, and the branch name points to its HEAD (the tip of the branch).

[caption id="attachment_132005" align="alignnone" width="1024"]Visualizing our branches before the merge Visualizing our branches before the merge[/caption]

To merge new_feature with master, run the following (after first making sure the master branch is active):

[code language="bash"]git checkout master
git merge new_feature
[/code]

The result can be visualized as shown below:

[caption id="attachment_132007" align="alignnone" width="1024"]The status of the repository after merging new_feature into master The status of the repository after merging new_feature into master[/caption]

To merge another_feature with new_feature, just run the following (making sure that the branch new_feature is active):

[code language="bash"]git checkout new_feature
git merge another_feature
[/code]

The result can be visualized as shown below:

[caption id="attachment_132009" align="alignnone" width="1024"]The status of the repository after merging another_feature into new_feature The status of the repository after merging another_feature into new_feature[/caption]

Important: Watch Out for Loops

The diagram above shows that this merge has created a loop in your project history across the two commits, where the workflows diverged and converged, respectively. While working individually or in small teams, such loops might not be an issue. However, in a larger team—where there might have been a lot of commits since the time you diverged from the main branch—such large loops make it difficult to navigate the history and understand the changes. We'll explore a way of merging branches without creating loops using the rebase command in Chapter 6.

[caption id="attachment_132011" align="alignnone" width="551"]The status of branch new_feature after the merge The status of branch new_feature after the merge[/caption]

This merge happened without any “conflicts”. The simple reason for that is that no new commits had been added to branch new_feature as compared to the branch another_feature. Conflicts in Git happen when the same file has been modified in non-common commits in both branches. Git raises a conflict to make sure you don’t lose any data.

We’ll discuss conflicts in detail in the next chapter. I mentioned earlier that branches can be visualized by just a simple pathway through commits. When we merge branches and there are no conflicts, such as above, only the branch pathway is changed and the HEAD of the branch is updated. This is called the fast forward type of merge.

The alternate way of merging branches is the no fast forward merge, by postfixing --no-ff to the merge command. In this way, a new commit is created on the base branch with the changes from the other branch. You are also asked to specify a commit message:

[code language="bash"]git merge --no-ff new_feature
[/code]

In the example above, the former (merging new_feature with master) was a fast forward merge, whereas the latter was a no fast forward merge with a merge commit.

While the fast forward style of merges is default, it’s generally a good idea to go for the no fast forward method for merges into the master branch. In the long run, a new commit that identifies a new feature merge might be beneficial, as it logically separates the part of the code that is responsible for the new feature into a commit.

Conclusion

What Have You Learned?

In this chapter, we discussed what branches are and how to manage them in Git. We looked at creating, modifying, deleting and merging branches.

What’s Next?

I’ve already spoken about how Git is beneficial to developers working in teams. The next chapter will look at this in more detail, as well as specific Git actions and commands that are frequently used while working in a distributed team.

Continue reading %Jump Start Git: Branching in Git%


by Shaumik Daityari via SitePoint

Are You Prepared for an Automated Future?

An automated car assembly line

Since the beginning of automated technology, some commentators have been in a panic about the loss of employment opportunities available to humans. Others have responded by pointing out that all this new technology tends to open up entirely new fields of work, more than making up for the jobs forever erased from the economy.

[author_more]

Something is changing. That perspective is predicated on the idea that machines need people to build, maintain, upgrade and repair them. Now, we’re starting to build machines that can do all these things without us.

We’re still in the early days of this shift, of course — these are very new technologies limited to a few applications, and even in those few applications, they aren’t always very good. But economists and technologists predict that 50% of the world’s jobs simply won’t exist twenty years from now, a much faster rate of obsolescence than anything we’ve seen before. Those who will be in the workforce over the next few decades need to start thinking about the skillset they’ll need to survive this future.

It’d be wise to cautiously assume that transitional measures, such as universal basic income, won’t be there to depend on — whether or not it seems likely that they will. You don’t want to end up in a corner.

Changing sentiment in political speech is one indicator that this is a concern we need to take seriously. To minimize public panic, officials tend to rely on the fact that new technology produces more jobs than it retires. But earlier this month, President Obama told town hall attendees that some jobs “are just not going to come back” and that young people should focus on acquiring skills that are highly intellectual and challenging in nature.

It’s one thing for a farrier witnessing the development of motorized vehicles to become a mechanic. When automated vehicles can be repaired by other automated machines, though, a much bigger leap is required. One must become a designer of machines, not a mere maintainer, to survive.

The higher intellectual hurdle to participation in design roles is one limiting factor. Another is that the market requires far fewer designers than maintainers, so when there’s little demand for maintainers, there’s also a scaling issue at play.

With this increasing rate of automation, it’s not just the roles being automated at risk. The functions that serve as support to the obsolete role suffer from less demand. Self-driving vehicles will put an end to the profession of driving trucks — one that feeds an enormous number of families around the world — but it will also mean truck drivers do not frequent motels, diners, mechanics and other establishments on their routes. In some locations, truck drivers are keeping those establishments in business.

Continue reading %Are You Prepared for an Automated Future?%


by Joel Falconer via SitePoint