The Keys to Advertising Your Web Design Business

Original Source: http://feedproxy.google.com/~r/1stwebdesigner/~3/kBaw0miLtno/

If you’ve just started a new business, congratulations! Once you have your site up and running, now comes the real challenge: advertising. You may not even know where to begin, so here’s a quick guide on how to spread the word and get your name out there.

Advertisement Banners

One of the easiest ways to advertise your business is with an online banner. These little rectangles don’t pull in many clicks, but they’re cheap. It can help immensely to advertise on relevant websites, and people may remember a good ad even if they don’t click right then.

You can use a service like Google Adwords, Facebook Ads or BlogAds. Just make sure to design a banner that’s memorable – not annoying or distracting. You are a designer, after all!

Advertisement Banners

Social Media

Want to know the best part of social media advertising? It’s free, assuming you don’t hire someone to do it for you! It’s also surprisingly effective. Generic social media accounts may fail, but if you put a bit of personality behind it, you‘ll find your business soaring. Interact first, promote your business second.

Take time to share curated content, partner with other businesses, share fun but relevant videos and images, give a behind-the-scenes look into web design life and use personal branding; people trust the individual more than the business.

Social Media

Directories

Get your business listed in a directory. Yelp, White Pages, Foursquare and any other relevant site you think will help. Many of these are free, so do your research. Don’t forget Google My Business, which adds a helpful little box on the right of search results that lists relevant information.

Email Marketing

Email marketing is highly effective – when done correctly. If done incorrectly, the only place you’ll be marketing to is the spam folder.

So grow your email list in legal ways, not by purchasing lists, but by offering an incentive for people to give you their info. Coupons, tips, eBooks, the list goes on. Personalize your emails so they get sent to the right people. Customers who’ve used your services before could get special rewards, while you can focus on converting those who haven’t. Autoresponders can automate the whole process.

Here’s a more in-depth guide if you’re confused. Email marketing services include Campaign Monitor, MailChimp and AWeber.

Email Marketing

Create a Portfolio

Of course your website itself should show off your skills, but you may wish to create a portfolio page or even a separate site. This can display the extent of your creativity, or use testimonials from past clients and examples of your work. Visitors will be hooked.

In Person

The last way to directly market your business is in-person – get your business cards ready and get out there! Attend seminars, conferences, events and try to secure a chance to participate if you can. Otherwise, it’s a learning experience.

Just remember business card etiquette. Don’t run around throwing cards at people; wait until you’re asked for it. Make sure to follow up with any businesses you exchange cards with. You might just end up with a partnership!

In Person

Say No

While not exactly a marketing tip, this is very important for designers to understand. Sometimes, you need to turn down a client. If you’re not comfortable, they’re overly demanding, or they aren’t paying their invoices, professionally turn them down and swallow the negative review. (Some review sites may allow you to respond with your side of the story, but be civil and calm.)

A new business, of course, often doesn’t have this luxury. You may need to deal with a few unpleasant clients. However, always be firm about getting paid – don’t work for free or get scammed out of money!

Getting the Word Out

Whether you have no advertising budget or are willing to spare any expense, you should have at least a few options. Social media, directories, portfolios and email marketing are often free – so start there if you don’t know what to do. Now that you know how to advertise your design business, which of these methods will you use?


Awaken Akira pays tribute to an animated classic

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/LTNE124JLkA/awaken-akira-pays-tribute-to-an-animated-classic

It's almost 30 years since Katsuhiro Otomo's Akira was released in Japan on 16 July 1988. Otomo's epic animated tale of teenage biker gangs and rampant genetic mutations in post-apocalyptic Neo-Tokyo took another three years to make it to the West, but once it arrived it quickly became a cult hit and is largely responsible for bringing the word 'manga' to Western vocabularies.

How to colour your manga art like a pro

Akira's notable for its insanely smooth and detailed hand-drawn animation, giving it an almost CG look years before actual CG animation became the norm. And while talk of a live action remake of Akira keeps cropping up, so far it's yet to materialise.

So for now we'll just have to make do with Awaken Akira, an amazing CG tribute created by a couple of dedicated Akira fans, Ash Thorp and Zaoeyo (XiaoLin Zeng).

Awaken Akira only lasts a minute – and that's including the credits – but it's a glorious taster of a dream Akira remake that we'd love to see in full. It took Thorp and Zaoeyo a year to make, fitting in work on it between other commitments, and demonstrates a similar attention to detail to that which you'll see in the original animated film.

Tetsuo!

Awaken Akira comes across like a teaser trailer or taster reel; rather than replicate action from the film, it instead recreates a selection of key shots from the film in CG, focusing on locations and items rather than the characters. It does an incredible job of conjuring up the flavour and atmosphere of Otomo's iconic original, and the enterprise is lent further impact with a score by Pilotpriest that echoes the original soundtrack superbly.

If you're keen to see how Thorp and Zaoeyo did it, they've thoughtfully collected a number of their processes into a YouTube playlist, showcasing and explaining their techniques over the course of 26 in-depth videos.

Kaneda!

The sheer amount of work that's gone into creating this minute of video gives you a whole new appreciation of the effort that Katsuhiro Otomo and his team must have put into animating the original film. 

It's a beautiful love letter to an animated classic, and even if it's all over just a little too quickly, it's just the incentive to dig out your DVD or Blu-Ray and watch the original again. Enjoy!

How to draw manga charactersThe 27 greatest animated music videos6 manga artists to watch out for

Building A Serverless Contact Form For Your Static Site

Original Source: https://www.smashingmagazine.com/2018/05/building-serverless-contact-form-static-website/

Building A Serverless Contact Form For Your Static Site

Building A Serverless Contact Form For Your Static Site

Brian Holt

2018-05-02T18:30:17+02:00
2018-05-02T17:49:19+00:00

Static site generators provide a fast and simple alternative to Content Management Systems (CMS) like WordPress. There’s no server or database setup, just a build process and simple HTML, CSS, and JavaScript. Unfortunately, without a server, it’s easy to hit their limits quickly. For instance, in adding a contact form.

With the rise of serverless architecture adding a contact form to your static site doesn’t need to be the reason to switch to a CMS anymore. It’s possible to get the best of both worlds: a static site with a serverless back-end for the contact form (that you don’t need to maintain). Maybe best of all, in low-traffic sites, like portfolios, the high limits of many serverless providers make these services completely free!

In this article, you’ll learn the basics of Amazon Web Services (AWS) Lambda and Simple Email Service (SES) APIs to build your own static site mailer on the Serverless Framework. The full service will take form data submitted from an AJAX request, hit the Lambda endpoint, parse the data to build the SES parameters, send the email address, and return a response for our users. I’ll guide you through getting Serverless set up for the first time through deployment. It should take under an hour to complete, so let’s get started!

The static site form, sending the message to the Lambda endpoint and returning a response to the user.The static site form, sending the message to the Lambda endpoint and returning a response to the user.

Nope, we can’t do any magic tricks, but we have articles, books and webinars featuring techniques we all can use to improve our work. Smashing Members get a seasoned selection of magic front-end tricks — e.g. live designing sessions and perf audits, too. Just sayin’! 😉

Explore Smashing Wizardry →

Smashing Cat, just preparing to do some magic stuff.

Setting Up

There are minimal prerequisites in getting started with Serverless technology. For our purposes, it’s simply a Node Environment with Yarn, the Serverless Framework, and an AWS account.

Setting Up The Project

The Serverless Framework web site. Useful for installation and documentation.

The Serverless Framework web site. Useful for installation and documentation.

We use Yarn to install the Serverless Framework to a local directory.

Create a new directory to host the project.
Navigate to the directory in your command line interface.
Run yarn init to create a package.json file for this project.
Run yarn add serverless to install the framework locally.
Run yarn serverless create –template aws-nodejs –name static-site-mailer to create a Node service template and name it static-site-mailer.

Our project is setup but we won’t be able to do anything until we set up our AWS services.

Setting Up An Amazon Web Services Account, Credentials, And Simple Email Service

The Amazon Web Services sign up page, which includes a generous free tier, enabling our project to be entirely free.

The Amazon Web Services sign up page, which includes a generous free tier, enabling our project to be entirely free.

The Serverless Framework has recorded a video walk-through for setting up AWS credentials, but I’ve listed the steps here as well.

Sign Up for an AWS account or log in if you already have one.
In the AWS search bar, search for “IAM”.
On the IAM page, click on “Users” on the sidebar, then the “Add user” button.
On the Add user page, give the user a name – something like “serverless” is appropriate. Check “Programmatic access” under Access type then click next.
On the permissions screen, click on the “Attach existing policies directly” tab, search for “AdministratorAccess” in the list, check it, and click next.
On the review screen you should see your user name, with “Programmatic access”, and “AdministratorAccess”, then create the user.
The confirmation screen shows the user “Access key ID” and “Secret access key”, you’ll need these to provide the Serverless Framework with access. In your CLI, type yarn sls config credentials –provider aws –key YOUR_ACCESS_KEY_ID –secret YOUR_SECRET_ACCESS_KEY, replacing YOUR_ACCESS_KEY_ID and YOUR_SECRET_ACCESS_KEY with the keys on the confirmation screen.

Your credentials are configured now, but while we’re in the AWS console let’s set up Simple Email Service.

Click Console Home in the top left corner to go home.
On the home page, in the AWS search bar, search for “Simple Email Service”.
On the SES Home page, click on “Email Addresses” in the sidebar.
On the Email Addresses listing page, click the “Verify a New Email Address” button.
In the dialog window, type your email address then click “Verify This Email Address”.
You’ll receive an email in moments containing a link to verify the address. Click on the link to complete the process.

Now that our accounts are made, let’s take a peek at the Serverless template files.

Setting Up The Serverless Framework

Running serverless create creates two files: handler.js which contains the Lambda function, and serverless.yml which is the configuration file for the entire Serverless Architecture. Within the configuration file, you can specify as many handlers as you’d like, and each one will map to a new function that can interact with other functions. In this project, we’ll only create a single handler, but in a full Serverless Architecture, you’d have several of the various functions of the service.

The default file structure generated from the Serverless Framework containing handler.js and serverless.yml.

The default file structure generated from the Serverless Framework containing handler.js and serverless.yml.

In handler.js, you’ll see a single exported function named hello. This is currently the main (and only) function. It, along with all Node handlers, take three parameters:

event
This can be thought of as the input data for the function.
context object
This contains the runtime information of the Lambda function.
callback
An optional parameter to return information to the caller.

// handler.js

‘use strict’;

module.exports.hello = (event, context, callback) => {
const response = {
statusCode: 200,
body: JSON.stringify({
message: ‘Go Serverless v1.0! Your function executed successfully!’,
input: event,
}),
};

callback(null, response);
};

At the bottom of hello, there’s a callback. It’s an optional argument to return a response, but if it’s not explicitly called, it will implicitly return with null. The callback takes two parameters:

Error error
For providing error information for when the Lambda itself fails. When the Lambda succeeds, null should be passed into this parameter.
Object result
For providing a response object. It must be JSON.stringify compatible. If there’s a parameter in the error field, this field is ignored.

Our static site will send our form data in the event body and the callback will return a response for our user to see.

In serverless.yml you’ll see the name of the service, provider information, and the functions.

# serverless.yml

service: static-site-mailer

provider:
name: aws
runtime: nodejs6.10

functions:
hello:
handler: handler.hello

How the function names in serverless.yml map to handler.js.

How the function names in serverless.yml map to handler.js.

Notice the mapping between the hello function and the handler? We can name our file and function anything and as long as it maps to the configuration it will work. Let’s rename our function to staticSiteMailer.

# serverless.yml

functions:
staticSiteMailer:
handler: handler.staticSiteMailer

// handler.js

module.exports.staticSiteMailer = (event, context, callback) => {

};

Lambda functions need permission to interact with other AWS infrastructure. Before we can send an email, we need to allow SES to do so. In serverless.yml, under provider.iamRoleStatements add the permission.

# serverless.yml

provider:
name: aws
runtime: nodejs6.10
iamRoleStatements:
– Effect: “Allow”
Action:
– “ses:SendEmail”
Resource: [“*”]

Since we need a URL for our form action, we need to add HTTP events to our function. In serverless.yml we create a path, specify the method as post, and set CORS to true for security.

functions:
staticSiteMailer:
handler: handler.staticSiteMailer
events:
– http:
method: post
path: static-site-mailer
cors: true

Our updated serverless.yml and handler.js files should look like:

# serverless.yml

service: static-site-mailer

provider:
name: aws
runtime: nodejs6.10

functions:
staticSiteMailer:
handler: handler.staticSiteMailer
events:
– http:
method: post
path: static-site-mailer
cors: true

provider:
name: aws
runtime: nodejs6.10
iamRoleStatements:
– Effect: “Allow”
Action:
– “ses:SendEmail”
Resource: [“*”]

// handler.js

‘use strict’;

module.exports.staticSiteMailer = (event, context, callback) => {
const response = {
statusCode: 200,
body: JSON.stringify({
message: ‘Go Serverless v1.0! Your function executed successfully!’,
input: event,
}),
};

callback(null, response);
};

Our Serverless Architecture is setup, so let’s deploy it and test it. You’ll get a simple JSON response.

yarn sls deploy –verbose
yarn sls invoke –function staticSiteMailer

{
“statusCode”: 200,
“body”: “{“message”:”Go Serverless v1.0! Your function executed successfully!”,”input”:{}}”
}

The return response from invoking our brand new serverless function.

The return response from invoking our brand new serverless function.

Creating The HTML Form

Our Lambda function input and form output need to match, so before we build the function we’ll build the form and capture its output. We keep it simple with name, email, and message fields. We’ll add the form action once we’ve deployed our serverless architecture and got our URL, but we know it will be a POST request so we can add that in. At the end of the form, we add a paragraph tag for displaying response messages to the user which we’ll update on the submission callback.

<form action=”{{ SERVICE URL }}” method=”POST”>
<label>
Name
<input type=”text” name=”name” required>
</label>
<label>
Email
<input type=”email” name=”reply_to” required>
</label>
<label>
Message:
<textarea name=”message” required></textarea>
</label>
<button type=”submit”>Send Message</button>
</form>
<p id=”js-form-response”></p>

To capture the output we add a submit handler to the form, turn our form parameters into an object, and send stringified JSON to our Lambda function. In the Lambda function we use JSON.parse() to read our data. Alternatively, you could use jQuery’s Serialize or query-string to send and parse the form parameters as a query string but JSON.stringify() and JSON.parse() are native.

(() => {
const form = document.querySelector(‘form’);
const formResponse = document.querySelector(‘js-form-response’);

form.onsubmit = e => {
e.preventDefault();

// Prepare data to send
const data = {};
const formElements = Array.from(form);
formElements.map(input => (data[input.name] = input.value));

// Log what our lambda function will receive
console.log(JSON.stringify(data));
};
})();

Go ahead and submit your form then capture the console output. We’ll use it in our Lambda function next.

Capturing the form data in a console log.

Capturing the form data in a console log.

Invoking Lambda Functions

Especially during development, we need to test our function does what we expect. The Serverless Framework provides the invoke and invoke local command to trigger your function from live and development environments respectively. Both commands require the function name passed through, in our case staticSiteMailer.

yarn sls invoke local –function staticSiteMailer

To pass mock data into our function, create a new file named data.json with the captured console output under a body key within a JSON object. It should look something like:

// data.json

{
“body”: “{“name”: “Sender Name”,”reply_to”: “sender@email.com”,”message”: “Sender message”}”
}

To invoke the function with the local data, pass the –path argument along with the path to the file.

yarn sls invoke local –function staticSiteMailer –path data.json

An updated return response from our serverless function when we pass it JSON data.

An updated return response from our serverless function when we pass it JSON data.

You’ll see a similar response to before, but the input key will contain the event we mocked. Let’s use our mock data to send an email using Simple Email Service!

Sending An Email With Simple Email Service

We’re going to replace the staticSiteMailer function with a call to a private sendEmail function. For now you can comment out or remove the template code and replace it with:

// hander.js

function sendEmail(formData, callback) {
// Build the SES parameters
// Send the email
}

module.exports.staticSiteMailer = (event, context, callback) => {
const formData = JSON.parse(event.body);

sendEmail(formData, function(err, data) {
if (err) {
console.log(err, err.stack);
} else {
console.log(data);
}
});
};

First, we parse the event.body to capture the form data, then we pass it to a private sendEmail function. sendEmail is responsible for sending the email, and the callback function will return a failure or success response with err or data. In our case, we can simply log the error or data since we’ll be replacing this with the Lambda callback in a moment.

Amazon provides a convenient SDK, aws-sdk, for connecting their services with Lambda functions. Many of their services, including SES, are part of it. We add it to the project with yarn add aws-sdk and import it into the top the handler file.

// handler.js

const AWS = require(‘aws-sdk’);
const SES = new AWS.SES();

In our private sendEmail function, we build the SES.sendEmail parameters from the parsed form data and use the callback to return a response to the caller. The parameters require the following as an object:

Source
The email address SES is sending from.
ReplyToAddresses
An array of email addresses added to the reply to the field in the email.
Destination
An object that must contain at least one ToAddresses, CcAddresses, or BccAddresses. Each field takes an array of email addresses that correspond to the to, cc, and bcc fields respectively.
Message
An object which contains the Body and Subject.

Is your pattern library up to date today? Alla Kholmatova has just finished a fully fledged book on Design Systems and how to get them right. With common traps, gotchas and the lessons she learned. Hardcover, eBook. Just sayin’.

Table of Contents →

Since formData is an object we can call our form fields directly like formData.message, build our parameters, and send it. We pass your SES-verified email to Source and Destination.ToAddresses. As long as the email is verified you can pass anything here, including different email addresses. We pluck our reply_to, message, and name off our formData object to fill in the ReplyToAddresses and Message.Body.Text.Data fields.

// handler.js
function sendEmail(formData, callback) {
const emailParams = {
Source: ‘your_email@example.com’, // SES SENDING EMAIL
ReplyToAddresses: [formData.reply_to],
Destination: {
ToAddresses: [‘your_email@example.com’], // SES RECEIVING EMAIL
},
Message: {
Body: {
Text: {
Charset: ‘UTF-8’,
Data: `${formData.message}nnName: ${formData.name}nEmail: ${formData.reply_to}`,
},
},
Subject: {
Charset: ‘UTF-8’,
Data: ‘New message from your_site.com’,
},
},
};

SES.sendEmail(emailParams, callback);
}

SES.sendEmail will send the email and our callback will return a response. Invoking the local function will send an email to your verified address.

yarn sls invoke local –function testMailer –path data.json

The return response from SES.sendEmail when it succeeds.

The return response from SES.sendEmail when it succeeds.

Returning A Response From The Handler

Our function sends an email using the command line, but that’s not how our users will interact with it. We need to return a response to our AJAX form submission. If it fails, we should return an appropriate statusCode as well as the err.message. When it succeeds, the 200 statusCode is sufficient, but we’ll return the mailer response in the body as well. In staticSiteMailer we build our response data and replace our sendEmail callback function with the Lambda callback.

// handler.js

module.exports.staticSiteMailer = (event, context, callback) => {
const formData = JSON.parse(event.body);

sendEmail(formData, function(err, data) {
const response = {
statusCode: err ? 500 : 200,
headers: {
‘Content-Type’: ‘application/json’,
‘Access-Control-Allow-Origin’: ‘https://your-domain.com’,
},
body: JSON.stringify({
message: err ? err.message : data,
}),
};

callback(null, response);
});
};

Our Lambda callback now returns both success and failure messages from SES.sendEmail. We build the response with checks if err is present so our response is consistent. The Lambda callback function itself passes null in the error argument field and the response as the second. We want to pass errors onwards, but if the Lambda itself fails, its callback will be implicitly called with the error response.

In the headers, you’ll need to replace Access-Control-Allow-Origin with your own domain. This will prevent any other domains from using your service and potentially racking up an AWS bill in your name! And I don’t cover it in this article, but it’s possible to set-up Lambda to use your own domain. You’ll need to have an SSL/TLS certificate uploaded to Amazon. The Serverless Framework team wrote a fantastic tutorial on how to do so.

Invoking the local function will now send an email and return the appropriate response.

yarn sls invoke local –function testMailer –path data.json

The return response from our serverless function, containing the SES.sendEmail return response in the body.

The return response from our serverless function, containing the SES.sendEmail return response in the body.

Calling The Lambda Function From The Form

Our service is complete! To deploy it run yarn sls deploy -v. Once it’s deployed you’ll get a URL that looks something like https://r4nd0mh45h.execute-api.us-east-1.amazonaws.com/dev/static-site-mailer which you can add to the form action. Next, we create the AJAX request and return the response to the user.

(() => {
const form = document.querySelector(‘form’);
const formResponse = document.querySelector(‘js-form-response’);

form.onsubmit = e => {
e.preventDefault();

// Prepare data to send
const data = {};
const formElements = Array.from(form);
formElements.map(input => (data[input.name] = input.value));

// Log what our lambda function will receive
console.log(JSON.stringify(data));

// Construct an HTTP request
var xhr = new XMLHttpRequest();
xhr.open(form.method, form.action, true);
xhr.setRequestHeader(‘Accept’, ‘application/json; charset=utf-8’);
xhr.setRequestHeader(‘Content-Type’, ‘application/json; charset=UTF-8’);

// Send the collected data as JSON
xhr.send(JSON.stringify(data));

// Callback function
xhr.onloadend = response => {
if (response.target.status === 200) {
// The form submission was successful
form.reset();
formResponse.innerHTML = ‘Thanks for the message. I’ll be in touch shortly.’;
} else {
// The form submission failed
formResponse.innerHTML = ‘Something went wrong’;
console.error(JSON.parse(response.target.response).message);
}
};
};
})();

In the AJAX callback, we check the status code with response.target.status. If it’s anything other than 200 we can show an error message to the user, otherwise let them know the message was sent. Since our Lambda returns stringified JSON we can parse the body message with JSON.parse(response.target.response).message. It’s especially useful to log the error.

You should be able to submit your form entirely from your static site!

The static site form, sending the message to the Lambda endpoint and returning a response to the user.The static site form, sending the message to the Lambda endpoint and returning a response to the user.

Next Steps

Adding a contact form to your static is easy with the Serverless Framework and AWS. There’s room for improvement in our code, like adding form validation with a honeypot, preventing AJAX calls for invalid forms and improving the UX if the response, but this is enough to get started. You can see some of these improvements within the static site mailer repo I’ve created. I hope I’ve inspired you to try out Serverless yourself!

Smashing Editorial
(lf, ra, il)

Is The Tor Browser Illegal?: What You Need to Know

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/6FXF-P7m1oU/is-the-tor-browser-illegal-what-you-need-to-know

The Tor Browser has been in the news for the past few weeks with people looking for reassurance that Tor Browser lets them browse anonymously and safely. The biggest question on everyone’s mind right now – is Tor illegal? Could we be in trouble if we use Tor Browser to access the dark web links? […]

The post Is The Tor Browser Illegal?: What You Need to Know appeared first on designrfix.com.

The Startup Button Lets Discover New Startups with Just A Click

Original Source: https://www.hongkiat.com/blog/startup-button-randomizer/

Free gallery of fresh startup companies that you can browse through to take a look at their work and new projects.

The post The Startup Button Lets Discover New Startups with Just A Click appeared…

Visit hongkiat.com for full content.

20 Responsive Image Galleries and Slideshows (2018)

Original Source: https://www.hongkiat.com/blog/free-responsive-image-gallery/

If your website is image-heavy i.e. a portfolio or photography website etc., then there are two things that you’ll be needing the most – photo gallery plugins to help you better manage…

Visit hongkiat.com for full content.

How to build a chatbot interface

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/IcBeA4d9R0Q/how-to-build-a-chatbot-interface

In the mid-2000s, virtual agents and customer service chatbots received a lot of adulation, even though they were not very conversational, and under the hood they were merely composed of data exchanges with web servers. 

Nowadays, even though a huge number of examples of ‘weak AI’ exist (including Siri, Alexa, web search engines, automated translators and facial recognition) and other topics such as responsive web design are hogging the limelight, chatbots are still causing a stir. With major investment from big companies, there remain plenty of opportunities to hack the conversational interfaces of the future.

How to design a chatbot experience

Sometimes they get a bad reputation, but chatbots can be useful. They don’t need to feel like a basic replacement for a standard web form, where the user fills in input fields and waits for validation – they can provide a conversational experience. 

Essentially we’re enhancing the user experience to feel more natural, like conversing with an expert or a friend, instead of web browser point-and-clicks or mobile gestures. The aim is that by providing empathetic, contextual responses, this technology will become embedded directly in people’s lives.

Watch the video below or read on to discover a practical way to design and build a chatbot, based on a real project-intake application in a service design practice.

01. Set a personality

It’s important to ensure the chatbot’s personality reflects the company it’s representing

As this practice serves over 110,000 members globally, the goal was to provide a quick, convenient and natural interface through which internal stakeholders could request effective digital services, instead of having to fill out confusing forms.

The first step was to establish the chatbot’s personality, as this would represent the voice of the service design team to its stakeholders. We built on Aarron Walter’s seminal work on design personas. This greatly helped our team develop the bot’s personality traits, which then determined the messages for greetings, errors and user feedback.

This is a delicate stage, as it affects how the organisation is perceived. To make sure we had as much information as possible, we immediately set up stakeholder workshops to nail the appropriate personality, colour, typography, imagery and user’s flow when engaging with the bot.

After we had gained all the necessary approvals – including seeking legal counsel – we set out to convert archaic request forms into a series of back- and-forth questions that mimicked a conversation between the stakeholders and a representative of our design services team.

02. Use RiveScript

This simple scripting language provides everything you need to design and build a chatbot POC

We knew we didn’t want to get too deep into AI markup language for the processing part – we just needed enough to jump-start the experience. 

RiveScript is a simple chatbot API that is easy enough to learn and sufficed for our needs. Within a few days we had the logic down to intake a project request from the bot, and parse it with enough business logic to validate and categorise it so it could be sent it through JSON REST services to the appropriate internal project tasking queue.  

To get this basic chatbot working, head to the RiveScript repo, clone it and install all the standard Node dependencies. In the repo you can also gain a taste of the interactions you can add with the various example snippets. 

Next, run the web-client folder, which turns the bot into a web page by running a basic Grunt server. At this point you can enhance the experience to suit your needs.

03. Generate your bot's brain

The next step is to generate the ‘brain’ of our bot. This is specified in files with the .RIVE extension, and thankfully RiveScript already comes with basic interactions out of the box (for example, questions such as ‘What is your name?’, ‘How old are you?’ and ‘What is your favourite colour?’).

When you initiate the web-client app using the proper Node command, the HTML file is instructed to load these .RIVE files.

Next we need to generate the part of our chatbot’s brain that will deal with project requests. Our main goal is to convert a selection of project tasking intake questions into a regular conversation.

So, for example:

Hello, how can we help?Great, how soon do we need to start?Can you give me a rough idea of your budget?Tell me more about your project…How did you hear about us?

A typical accessible web form would look like this:

With web forms, we’re very familiar with certain patterns: you click the Submit button, all form data is sent to another page where the request is processed, and then most likely a cheeky Thank you page pops up. 

With chatbots, we’re able to take the interaction of submitting a request, and make it more meaningful.

04. Design a voice

To convert this form to a conversational user interface served in RiveScript’s chatbot web client, we need to convert the information architecture from rigid to fluid; or field labels into UI strings. 

Let’s consider some accessible field labels, and their related question tone:

Request: How can we help? Not sure? Do you mind if I ask a few questions?Timeline: How soon do we need to get started?Budget information: Can you give me a rough idea of your budget?Project description: OK, can you tell me a summary of the problem to be solved?Reference: Also, who referred you to us?

Next we need to convert the web form’s code into AI script, following RiveScript’s very learnable processing logic for two-way conversations:

05. Request submission

As opposed to standard form variables being sent to another page or service to process, chatbots can validate and submit information entered by the user in a chat window (or spoken) immediately, which means users can also revisit previously entered values easily. 

We needed to send the user’s request entered in the chatbot UI via the JSON REST API to an external project tasking server.

In RiveScript-js we are free to make use of an XMLHttpRequest object to submit the request almost simultaneously, as the data is entered by the user:

06. Do not fear the chatbot

Soon, current ways of interacting with computers to obtain information will give in to AI-based technology like chatbots, where people just make simple voice commands, like we've seen with tech such as Amazon Echo and Google Home.

The web design community need not fear – we should all be embracing the added value of this new technology. 

It could be a game-changer for the companies it works for, offering fully scalable customer service and improved customer intelligence. 

This article was originally featured in net magazine,  the world's best-selling magazine for web designers and developers. Subscribe here.

Related articles:

How chatbots are learning – interview with Giles ColborneHow the intelligent web will change our interactionsHow conversational interfaces are innovating banking

Bootstrap Card Component: a Complete Introduction

Original Source: https://www.sitepoint.com/bootstrap-card-component-introduction/

In this article, I’m going to introduce you to the Bootstrap card component and walk you through its many features and uses. By the end of this tutorial, you’ll be able to incorporate Bootstrap cards in your web projects for great layouts and page content organization.

Bootstrap is the most popular HTML, CSS, and JavaScript framework for quickly creating responsive and mobile-first web layouts.

Using Bootstrap offers many advantages to developers, including the following:

you can easily and quickly build a responsive layout by having only some knowledge of HTML and CSS
the library was built to be mobile-first from the core
it’s compatible with all modern browsers etc.
it uses Flexbox for its grid system
it provides tons of features and components.

The latest release of Bootstrap offers many new, modern features — such as the support for Flexbox, and the new card component, which replaces panels, thumbnails and wells from earlier versions of the library.

What Is the Bootstrap Card Component?

Bootstrap introduces a new UI component for creating cards which provides a flexible and stylish container for showing content. Cards come with minimal styling, but you can easily extend them with extra styling options.

This component is built on top of Flexbox, and you can use the Bootstrap spacing utility classes for margins and padding.

Cards can conveniently accommodate different types of content like title, subtitle, body copy, and images etc., and optional header and footer sections. You can also include different sections (card blocks) to construct different types of cards depending on your use.

Including Bootstrap in Your Project

You can very easily start using Bootstrap in your website by either including it from a CDN or downloading it from getbootstrap.com.

For the sake of introducing the new Bootstrap card component, you’re going to create a simple HTML page with Bootstrap styling to demonstrate the basic elements of the card component. Go ahead and create the index.html file inside your project folder, then add the following content from the docs starter template:

<!doctype html>
<html lang=”en”>
<head>
<!– Required meta tags –>
<meta charset=”utf-8″>
<meta name=”viewport” content=”width=device-width, initial-scale=1, shrink-to-fit=no”>

<!– Bootstrap CSS –>
<link rel=”stylesheet” href=”https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css” integrity=”sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm” crossorigin=”anonymous”>

<title>Bootstrap Card Example</title>
</head>
<body>
<div class=”container”>
</div>

<!– Optional JavaScript –>
<!– jQuery first, then Popper.js, then Bootstrap JS –>
<script src=”https://code.jquery.com/jquery-3.2.1.slim.min.js” integrity=”sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN” crossorigin=”anonymous”></script>
<script src=”https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js” integrity=”sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q” crossorigin=”anonymous”></script>
<script src=”https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js” integrity=”sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl” crossorigin=”anonymous”></script>
</body>
</html>

We’ve included Bootstrap files and their dependencies (jQuery and popper.js) from different CDNs, then created a container division.

Minimal Styling for Cards

In order to create a basic card, we need to —

use .card with a div tag to create the outer container
add the .card-body class to an inner div tag to create the card body
use .card-title and card-subtitle classes with heading tags for adding the title and the subtitle
use the card-text class with <p> tags to add textual content
use the card-img-top class with the <img> tag to add an image to the top of the card.

These are the basic elements that constitute a full but basic card layout, as we can see from the following example:

<div class=”card”>
<img class=”card-img-top” src=”https://source.unsplash.com/daily” alt=”Card image top”>
<div class=”card-body”>
<h3 class=”card-title”>Card title</h3>
<h4 class=”card-subtitle”>Card subtitle</h4>
<p class=”card-text”>This is a simple Card example</p>
</div>
</div>

This is a screenshot of the result:

Bootstrap card component: Basic card layout

As can be seen, the card takes the full width of its container div.

By simply switching the card-body class with the card-img-overlay class, we can use the image as an overlay:

Bootstrap card component: Using the image as an overlay

We can also use the class .card-img-bottom with the <img> tag to add the image at the bottom of the card:

<div class=”card”>
<div class=”card-header”>
This is a header
</div>
<img class=”card-img-top” src=”https://source.unsplash.com/daily” alt=”Card image top”>
<div class=”card-body”>
<p class=”card-text”>A Card with a top and bottom images</p>

</div>
<img class=”card-img-bottom” src=”https://source.unsplash.com/daily” alt=”Card image top”>

<div class=”card-footer”>
This is a footer
</div>
</div>

Bootstrap card component: Adding the image at the bottom of the card

The card top and bottom images are called image caps.

Continue reading %Bootstrap Card Component: a Complete Introduction%

The Best Adobe XD Mobile App Freebies for UI Designers

Original Source: http://feedproxy.google.com/~r/1stwebdesigner/~3/UB0KOAQ3OgM/

Adobe’s XD program is a direct competitor to Sketch. And while XD is still pretty new it’s catching on like wildfire.

If you’re thinking of trying Adobe XD, you can sign up for the beta and see what you think. If you really like the program, you might even keep it long term, and for that, you’ll probably want some design assets to play around with.

I’ve curated a handful of Adobe XD freebies already released on the web. All of these are editable just like PSD freebies and there’s a lot of variety to pick from.

All the Mobile UI Kits You Could Ask For


DOWNLOAD NOW

Wires for Adobe XD

wires adobe xd wireframe

The Wires Kit for Adobe XD is perhaps the best wireframing kit out there. It was designed specifically for designers by Kyle Galle, a very skilled designer in his own right.

You can grab the Wires kit for free and reuse it for all your UI projects. It comes with a massive collection of 170 mobile templates, 90 website templates, 240 different page elements and over 170 custom icons.

And yes, all of that is 100% free to download.

iPhone X Mockup & iOS 11 GUI

iphonex ios 11 xd gui

Whenever there’s a new iPhone launch you can bet designers are hard at work releasing UI kits to match. With this new Apple device GUI it nails two kits in one: the newer iOS 11 GUI along with a mockup for the new iPhone X.

It all comes in one massive Adobe XD file created by designer Jason Chuang.

The pack includes tons of sample screens that you can rework and style to suit your own application. Not to mention many of these elements should work for iOS 10 and older.

UI Prototype Screens

ui prototype screens freebie

Talented UI designer Gabriel Cambreling released these prototyping screens for general download. And they’re a great starting point for tinkering in Adobe XD.

These prototypes cover the bases for most of the screens you might plan for a mobile app. List views, login pages, maps, sliding responsive navigation along with other general page designs.

Spoon + Fork iOS UI

spoon and fork gui xd

Now for a more detailed UI kit check out the Spoon + Fork set created by Aprylle Ricafort.

This works like a mobile iOS food app with custom icons, graphics, and a beautiful color scheme. All the elements are 100% vectorized so you can resize them and rework everything if you want.

Anyone looking for a full UI kit for Adobe XD should definitely grab a copy of Spoon + Fork and keep it saved for project work.

Mobile E-Commerce Checkout

ecommerce cart xd freebie

Ecommerce shopping is huge and growing every year. A solid interface is required to increase conversions and you’ll see this mostly in the Mobile E-Commerce Checkout.

The freebie comes with 15 unique line icons and it’s fully open source including all the Google webfonts. Plus this interface basically covers the line of every page you’ll need for a trustworthy shopping app.

Piggy Bank App

piggy bank app freebie

This delightful little piggy bank app UI was released for free by designer Caio in late 2017. It’s one of the newest freebie kits on the web and it’s certainly a simple design.

This probably won’t help you prototype an entire working app, but it will help you learn the XD interface.

Check this out if you’re brand new to Adobe Experience Design and want a simple freebie to mess around with.

Facebook Messenger Bot UI

facebook messenger app gui

The Facebook Messenger app is pretty cool and lets you connect with people wherever you are. It also comes from one of the largest tech companies in the world known for designing great interfaces.

Vladimir Tatarovich’s Facebook Messenger Bot UI is a free UI kit designed around simple app interface screens.

This doesn’t exactly mimic the Facebook messenger but instead tries to rebuild using their existing style. A great starting point for designing your own mobile apps.

XD Mobile Apps

xd mobile app freebie

Here’s another pack dedicated to mobile app GUIs although this one’s a little more generic. But while the styles don’t match a particular brand, these styles are still incredibly useful.

The kit comes with dozens of custom screens including dynamic elements like graphs, checkout pages, audio/video players, ticket purchasing screens and user profiles(plus a whole lot more).

Glancing over this app UI kit you may think it’s just another simple freebie.

But this is by far one of the best freebies you can nab to mess around in XD.

Voice App Concept

voice app freebie

If you do want something real simple to get started with XD try downloading this voice app GUI by designer Ashwin Merle.

It only comes with a few screens, but they work with custom vector elements and some pretty cool text effects to boot.

Walkthrough Screens

walkthrough screens

Digital walkthroughs are crucial to the onboarding process and you should always try to work this into your applications.

If you’re looking for some XD inspiration take a look at this walkthrough screen pack that offers 5 free guided GUI screens built solely for XD. The kit is naturally 100% free and it’s a cool way to gather ideas for your app designs.

Messenger UI Kit

messenger gui kit freebie

Mobile networking is huge and messengers are crucial to every networking app. Whether you’re designing one yourself or just building a practice project, you can learn a lot from this messenger UI kit.

Designer Egor Kuznetsov released this for free and it serves a great purpose for XD users who wanna play around with messenger interfaces.

This kit offers dozens of screens and while the text is in Russian you can always change that with a bit of XD magic.

Bamb UI Kit

bamb ui freebie xd

It was tough finding quality UI kits but I think the Bamb UI really takes the cake.

No doubt this is one of the most complete UI kits you’ll find for Adobe XD. It comes with a specific design style for colors, gradients, typography, and spacing for mobile app GUIs.

Not to mention this thing is totally free, so it’s a great asset for screwing around with XD.

Wallet Mobile App

xd freebie wallet app

Banks and credit card companies usually offer mobile apps for banking on the go. If you’re working on a project like that you might grab a copy of this wallet app GUI kit for Adobe XD.

It comes with quite a few different screen styles for news, account balance info, and for moving money around. This one’s designed around a Bitcoin wallet but you could rework the style to fit anything.

So these are just my top picks for XD freebies, but new ones come out every few months.

If you have time to search around I highly recommend browsing through the free Adobe XD files on PSDDD.co to find more.


The New Gmail – Material Design and 8 New Features

Original Source: https://www.hongkiat.com/blog/new-gmail-material-design-and-features/

Gmail has received a major update recently, which brings the beautiful material design interface to our favorite email provider. That is not all, it introduces many requested features to help…

Visit hongkiat.com for full content.