This month, we are looking and some rather obvious visual trends in web design. While some trends are rooted more in the user experience or cool JavaScript, others are purely aesthetic. That’s what you’ll see on the list this month.
From color to shapes to a style of photography, here’s a look at what’s trending this month.
Black and White
Black and white design patterns are timeless and classic. They have a feeling of sophistication that can work with projects of all kinds.
And while most people immediately think “black and white” photos, black and white patterns can extend to other elements in a website design as well – navigation, typography, video, etc.
The neat thing about black and white website designs is that unlike print, where black and white was the common standard for newspapers, books and magazines for a long time (and still to some degree today), it stands out because of the lack of color. The richness of black and white on a screen allows for depth of visuals as well.
Each of the examples below uses this color – or lack thereof – to help bring attention and focus to the messaging on the websites. Black and white in these examples also creates a certain emotional feel for the user.
When planning a black and white design, you can go all in with no other color at all or pick an accent color, such as American Documentary, to help drive eyes to focal points or calls to action on the screen. There’s no right or wrong choice here. The decision to use color (or not) in a black and white design pattern is based on what you want users to accomplish with the design and the experience they should take away from it.
If you clock through each of the examples below, you can see how each uses a different technique to create engagement:
Designing with circles is not new. The “perfect” shape is pleasing to the eye and is even part of Google’s Material Design standards – you’ve surely noticed all those round buttons.
When it comes to using circles in website design projects, it’s important to think about the meaning of this shape. It can add an extra layer of content to your design.
Gold Kant uses circles in a photo. It’s a little less in your face than as a UI element, but the aura of harmony and energy is there.
Google’s Game of the Year uses on-brand circles to entice users to click on answers to game questions. The circles in the game mimic the colors and sizes of circles in Material Design interfaces and re-emphasize that circles – in the land of Google – are meant to be interacted with.
Marjin W. Bankers uses a circular logo and giant circle to represent types of work performed. Both circles imply motion – the logo circle because it is open and the bigger circle because the colored bar is moving in the form of a wheel.
“Faceless” Photos
An element of engaging design is to include faces of people in images. It can help users connect.
Then why are so many projects using “faceless” photos? Each of the examples below features imagery with people in it, but no faces.
This style of website design and photo selection has a real purpose: It allows users to picture themselves in the scenes that are displayed. You might be the person getting your hair cut or one of a few friends at a table having fun at a meal. Or you might just be intrigued by the series of images without that eye-to-eye connection.
When there’s a face on the screen, users’ eyes will naturally pause almost to make eye content with the subject of the image (particularly if the image and face is large). Without this pause – as quick as it might be – users will continue to scan the complete design. They might see something they wouldn’t otherwise, and it can add a different focal point to the image.
While this faceless photo style doesn’t work for everything, it can be effective. Use this concept for more general ideas that don’t need a strong emotional tug.
And if you are planning a faceless design, have that conversation with the photographer so that images are composed with this in mind. Just cropping off a head will not result in the same charming effects and could actually end up quite jarring.
Another use for faceless photos? If you have to use stock images, this can be an effective trick. It can hide all-too-common stock models so your design doesn’t look canned.
The nice thing about visual trends is that you can incorporate them into other trending elements, or with each other. Black and white photography, for example, is something that’s been used for decades across all design disciplines; plus you can pair it with some cool UX effects to really make the project stand out.
What trends are you loving (or hating) right now? I’d love to see some of the websites that you are fascinated with. Drop me a link on Twitter; I’d love to hear from you.
WordPress is one of the most popular platforms around. From blogs to web pages, the software packs a punch for hardcore developers and newbies alike. But then there are the code vulnerabilities. Fortunately, there are ways to minimize these security issues and create beautiful and functional pages that people can safely visit again and again.
The following tips should help overcome the more common WordPress vulnerabilities.
1. Keep Your Plugins Up to Date
Plugins are perhaps the most exciting thing about WordPress. With them, your site can offer features and functions perhaps to the limit of your imagination. So functional that, in the hands of a skilled website builder, it’s possible to use the right combination of plugins to create pages that perform much like an app.
The thing to remember is that plugins come with vulnerabilities which are usually not known at the time of release. It’s only after hackers push and prod the code until they find a weakness and then develop malware that the problems emerge. Typically, fixes are produced and included in the next release to compensate and protect site owners.
Having said this, it’s in your best interest to be on the lookout for new versions of plugins you use. More to the point, you should replace the older versions as soon as more recent iterations are available. Even if you’ve not noticed problems, make the updates.
2. Only Use Plugins From a Trusted Source
WordPress is not the only place to find compatible plugins. They are also developed and released by other parties for free or purchase off platform. Many plugins you find in this manner are stable and relatively free of vulnerabilities but others are built with malware included specifically to penetrate and infect any system it is installed in.
Your best bet is to only use plugins from a trusted source. Trusted means that the developer takes the same precautions that come with the creation of WordPress branded plugins. The developer should also actively monitor the device in the event security issues are uncovered and need to be resolved in the form of a new version.
If you don’t see evidence that a plugin creator is consistently spotting and correcting vulnerabilities, don’t trust it and certainly don’t install it. If you already have, immediately uninstall and remove that plugin from your website.
3. Get Rid of Plugins You No Longer Use
Do you have plugins installed that are no longer used? If so, ditch them immediately. There are a few reasons we say this:
Old plugins that you never use are old versions with old protections; they may not stop viruses or malware from infecting your site.
They take up space you could use for something more practical.
It’s easier to manage your pages when you only have plugins installed that are needed.
Make it a point to review your plugins at least once a quarter. Maybe even monthly if you don’t have anything better to do. Find a few you don’t use any more? Get rid of them. Remember that if you need them in the future, it’s easy enough to re-install the most recent release.
4. Protect Your Site From SQL Injection and URL Hacking
Structured Query Language is important, but injections of SQL by an attacker can wreak havoc on your pages. They can alter, add, or replace the content on those pages and do quite a bit of damage. Hacking your Uniform Resource Locator (URL) makes it possible to alter the address of your pages and redirect readers to pages created by a hacker. Not only do you lose business, but your reputation could take a serious hit.
The right type of WP Config tool helps to prevent both these possible issues. As with all of the tools, make sure you use the latest generation.
5. Change the Default Prefix For Your Site’s Database
Upon installation, WordPress creates a default prefix for your database tables. It’s a good idea to take the time to customize those prefixes since a common hacker trick is to use specialized software to identify and alter them, then use SQL injections to take over.
Changing database prefixes is not that difficult. In fact, it can be done fairly quickly. See it as one more way to ensure your hard work isn’t corrupted or used without your permission.
6. Use Two-Factor Authentication
Two-factor authentication has become a big deal in recent years. Essentially it’s a two-step login process that, in addition to the usual username and password, requires an additional code sent to you by phone or some other alternate means.
This process adds an extra step but makes it more difficult for unauthorized parties to gain access since they likely won’t be able to hack your computer and phone simultaneously.
7. Don’t Go Online Without a Virtual Private Network (VPN)
If this is your first exposure to the idea, personalized encryption tools, in the form of a VPN, have brought intelligence agency-level privacy and anonymity to the masses. This software, once installed, creates an encrypted connection (some like to think of it as a tunnel) every time you go online, even if you’re knocking back caffeine down at the local coffee shop using public Wi-Fi.
A VPN, used in conjunction with other open source privacy tools, is at least an attempt at a solution to the outbreak of hacking, data breaching, and government spying that is sweeping the internet with no letup in sight. A VPN runs in conjunction with your ISP service and should cost no more than $7 to $15 a month.
8. Go With Dedicated Rather than Shared Hosting
Shared hosting is fine and may work well for many people but business sites and especially if you collect customer data (gotta be aware of the new GDPR regulations), you might consider the extra expense of dedicated hosting.
Most experts agree that the dedicated hosting environment offers tighter security, which is a good thing.
8. Monitor and Update Administrative Privileges Regularly
One of the more common tasks overlooked in WordPress is updating administrative privileges, which needs more attention than simply deleting privileges when an employee leaves the business.
You should also update privileges around situations like promotions, changes in work assignments, and anything else that could leave an employee with access to data he or she no longer needs.
Old and unused privileges increase the odds of information disclosures if an infection is able to find a way to exploit them. Make sure administration level rights are limited to active employees who actually need access to that level of control.
Final Thought
Remember that WordPress continues to develop and release security tools that you can put to good use. Review those resources as they become available. One or more of them may be just what you need to make your security even better. And always…ALWAYS…update the main installation any time you are prompted to do so in the dashboard area. Hackers are always trying to uncover new methods of entry and this is how you stop them.
On the surface, it seems simple enough to create a web design contract. You just find a boilerplate web design contract or a template and edit to your heart’s content, right?
Well, not exactly. You see, not all web design contracts are created equal, and using a free website design contract you pulled off the web might not give you all of the legal protections you’re rightfully entitled to. And while we’re not lawyers (we are, however, fantastic web designers), knowing what a great web design contract should contain is the first step toward making sure yours is as ironclad as possible.
With that being said, you should always consult a lawyer who is well-versed in contracts before you jump right in. Now, let’s take a closer look at the components that make up a great web design contract:
Outlining the Scope of the Project
Every professional web developer dreads those two little words that signify that a project is going to go on a lot longer than anticipated — “scope creep”. This is when clients (sometimes intentionally, sometimes not) ask for more than what was initially agreed to. In other words, the scope of the project creeps up little by little, nibbling away at your time and profits.
A proper web design contract will outline exactly what’s expected and what will be delivered, and by when. Then, if the client starts asking for additional things, you can always fall back to the contract and demonstrate that to add these things will add to the cost and delivery time, putting the ball back in the client’s court to determine if this is something they really want to move ahead with or not.
All the Little Things
There are lots of little things that often get missed, even in the most thorough web design contracts. These include things like:
Who is providing the content for the website? Will the client be providing this? Will a third party copywriter or content writer be brought on board? Will the designer be responsible?
What about debugging the code? There can sometimes be hiccups with regard to coding and proper implementation. Who is responsible for this?
Who is going to test the design on various browsers and mobile devices to determine its responsiveness to various screen sizes and load times?
Making it clear who is responsible for which part of the contract (and then getting them to sign off on it) now will help save a lot of headaches later.
Testing, Tweaking and Technical Support
Even the most flawless website design contract needs to incorporate what will happen after the work is completed. Oftentimes, there will be updates with various plugins and integrations, and tests that need to be performed in order to ensure that the site is performing as well as it can be under various conditions.
Sometimes, clients opt to have their design team handle ongoing maintenance and tech support, updating the site and adding new features as time goes by. Including this in your contract, as well as specifying what will be done by the design team and what will be handled by the client) can help provide an additional and lucrative stream of income for your web development agency, month after month.
What if I Need to Make Changes?
Web design contracts are often saved in PDF format for easy portability across platforms and devices. PDF files can also be designed to be filled in with relevant information such as dates and addresses. They can also be programmed to accept electronic signatures. PDF is an older format that has stood the test of time while new features have become available to make using them even more convenient.
But one of the things that has always presented difficulty when considering web design contracts is making changes. Fortunately, there are several tools available to help edit a PDF on PC and Mac, even after you’ve saved it.
And keep in mind that a contract is only the first step. Keep the lines of communication open between you and your client while providing them with ongoing updates to show progress on their project. This allows you the freedom and flexibility to allow a designer-client business relationship to flourish while enjoying the strong foundation of a contract that’s built-in everyone’s best interest.
Every week users submit a lot of interesting stuff on our sister site Webdesigner News, highlighting great content from around the web that can be of interest to web designers.
The best way to keep track of all the great stories and news being posted is simply to check out the Webdesigner News site, however, in case you missed some here’s a quick and useful compilation of the most popular designer news that we curated from the past week.
Note that this is only a very small selection of the links that were posted, so don’t miss out and subscribe to our newsletter and follow the site daily for all the news.
Google Takes its First Steps Toward Killing the URL
Palettte App
24 Expert Opinions on UI Design Trends 2019
I Am not a Real Programmer
Zara’s New Logo May Be the Future of Branding, Love it or Hate it
How UX Design Builds Trust and Loyalty for Your Website
The Worst Career Advice I Ever Received
The Digital Handbook for Agency People
CSS Position Sticky – How it Really Works!
Best of UX Design Case Studies 2018
SocialSizes.io – Image and Video Sizes for Social Media
Benefits and Pitfalls of Being a Freelance Designer
CSSans Pro — the Colourful, Sassy, CSS Font
Fonts Used to Catch a Fraudster
5 Ways to Keep your WordPress Site Safe
We Value your Privacy Now, but Maybe not Later
Smartphone Design Hasn’t Evolved in a Decade; that’s About to Change
Conversational AI is the Skeuomorphism of VUI
Design Patterns for Mental Health
The Bias of Colour
The Problem with Power Users
An In-depth Look at Ethics in Design
Why this Stylized Filter is all Over your Instagram Feed
The Women Running for President are Breaking the Rules of Branding
A Novel Approach to Onboarding
Want more? No problem! Keep track of top design news from around the web with Webdesigner News.
Most web applications built today receive data from an API. When fetching that data, we have to take certain situations into consideration where the data might not have been received. Perhaps it was a lost connection. Maybe it was the endpoint was changed. Who knows. Whatever the issue, it’s the end user who winds up with a big bag of nothing on the front end.
So we ought to account for that!
The common way of handling this is to have something like an isLoading state in the app. The value of isLoading is dependent on the data we want to receive. For example, it could be a simple boolean where a returned true (meaning we’re still waiting on the data), we display a loading spinner to indicate that the app is churning. Otherwise, wee’ll show the data.
Oh god, no!
? Credit: Jian Wei
While this isn‘t entirely bad, the awesome folks working on React have implemented (and are continuing to work on) a baked-in solution to handle this using a feature called Suspense.
Suspense sorta does what its name implies
You may have guessed it from the name, but Suspense tells a component to hold off from rendering until a condition has been met. Just like we discussed with isLoading, the rendering of the data is postponed until the API fetches the data and isLoading is set to false. Think of it like a component is standing in an elevator waiting for the right floor before stepping out.
At the moment, Suspense can only be used to conditionally load components that use React.lazy() to render dynamically, without a page reload. So, say we have a map that takes a bit of time to load when the user selects a location. We can wrap that map component with Suspense and call something like the Apple beachball of death to display while we’re waiting on the map. then, once the map loads, we kick the ball away.
// Import the Map component
const Map = React.lazy(() => import('./Map'));
function AwesomeComponent() [
return (
// Show the <Beachball> component until the <Map> is ready
<React.Suspense fallback={<Beachball />}>
<div>
<Map />
</div>
</React.Suspense>
);
}
Right on. Pretty straightforward so far, I hope.
But what if we want the fallback beachball, not for a component that has loaded, but when waiting for data to be returned from an API. Well, that’s a situation Suspense seems perfectly suited for, but unfortunately, does not handle that quite yet. But it will.
In the meantime, we can put an experimental feature called react-cache (the package previously known as simple-cache-provider) to demonstrate how Suspense ought to work with API fetching down the road.
Let’s use Suspense with API data anyway
OK, enough suspense (sorry, couldn‘t resist). Let’s get to a working example where we define and display a component as a fallback while we’re waiting for an API to spit data back at us.
Remember, react-cache is experimental. When I say experimental, I mean just that. Even the package description urges us to refrain from using it in production.
Let’s start by generating a new React application using create-react-app.
## Could be any project name
create-react-app csstricks-react-suspense
This will bootstrap your React application. Because the Suspense API is still a work in progress, we will make use of a different React version. Open the package.json file in the project’s root directory, edit the React and React-DOM version numbers, and add the simple-cache-provider package (we’ll look into that later). Here’s what that looks like:
In this tutorial, we will build the functionality to fetch data from an API. We can use the createResource() function from simple-cache-provider to do that in the src/fetcher.js file:
So, here’s what’s happening there. The sleep() function blocks the execution context for a specific duration, which will be passed as an argument. The sleep() function is then called in the loadProfiles() function to stimulate a delay of three seconds (3,000ms). By using createResource() to make the API call, we either return the resolved value (which is the data we are expecting from the API) or throw a promise.
Next, we will create a higher-order component called withCache that enable caching on the component it wraps. We’ll do that in a new file called, creatively, withCache.js. Go ahead and place that in the project’s src directory.
This higher-order component uses SimpleCache from the simple-cache-provider package to enable the caching of a wrapped component. We’ll make use of this when we create our next component, I promise. In the meantime, create another new file in src called Profile.js — this is where we’ll map through the results we get from the API.
import React, { Fragment } from 'react';
import loadProfiles from './fetcher'
import withCache from './withCache'
// Just a little styling
const cardWidth = {
width: '20rem'
}
const Profile = withCache((props) => {
const data = loadProfiles(props.cache);
return (
<Fragment>
{
data.results.map(item => (
<div key={item.login.uuid} className="card" style={cardWidth}>
<div>
<img src={item.picture.thumbnail} />
</div>
<p>{item.email}</p>
</div>
))
}
</Fragment>
)
});
export default Profile
What we have here is a Profile component that’s wrapped in withCache the higher-order component we created earlier. Now, whatever we get back from the API (which is the resolved promise) is saved as a value to the data variable, which we’ve defined as the props for the profile data that will be passed to the components with cache (props.cache).
To handle the loading state of the app before the data is returned from the API, we’ll implement a placeholder component which will render before the API responds with the data we want.
Here’s what we want the placeholder to do: render a fallback UI (which can be a loading spinner, beach ball or what have you) before the API responds, and when the API responds, show the data. We also want to implement a delay (delayMs ) which will come in handy for scenarios where there’s almost no need to show the loading spinner. For example; if the data comes back in less than two seconds, then maybe a loader is a bit silly.
delayMs, fallback and children will be passed to the Placeholder component from the App component which we will see shortly. The Timeout component returns a boolean value which we can use to either return the fallback UI or the children of the Placeholder component (the Profile component in this case).
Here’s the final markup of our App, piecing together all of the components we’ve covered, plus some decorative markup from Bootstrap to create a full page layout.
class App extends React.Component {
render() {
return (
<React.Fragment>
// Bootstrap Containers and Jumbotron
<div className="App container-fluid">
<div className="jumbotron">
<h1>CSS-Tricks React Suspense</h1>
</div>
<div className="container">
<div>
// Placeholder contains Suspense and wraps what needs the fallback UI
<Placeholder
delayMs={1000}
fallback={
<div className="row">
<div className="col-md">
<div className="div__loading">
<Loader />
</div>
</div>
</div>
}
>
<div className="row">
// This is what will render once the data loads
<Profile />
</div>
</Placeholder>
</div>
</div>
</div>
</React.Fragment>
);
}
}
That’s a wrap
Pretty neat, right? It’s great that we’re in the process of getting true fallback UI support right out of the React box, without crafty tricks or extra libraries. Totally makes sense given that React is designed to manage states and loading being a common state to handle.
Remember, as awesome as Suspense is (and it is really awesome), it is important to note that it’s still in experimental phase, making it impractical in a production application. But, since there are ways to put it to use today, we can still play around with it in a development environment all we want, so experiment away!
Folks who have been working on and with Suspense have been writing up their thoughts and experience. Here are a few worth checking out:
I came across this update from Scott Kellum’s and Sal Hernandez’s project Typetura via my Medium feed this morning, and what a delight?!
(Also, wow, I really have been out of the game for a minute.)
Typetura.js is a fluid design solution, for any property, based on any input. It’s not for just typography across screen sizes. Transition between anything — width, height, scroll position, cursor position, and more.https://t.co/EoouX0PkGC
This is quite exciting! Typetura wants to deal with some of the main problems that come up when utilizing fluid type in your CSS.
> Typetura is a fluid typesetting tool. Use the slider at the top of the screen to select the breakpoint you want to style, then use the panel on the left of the screen to style your page.https://t.co/6cjgdEylwY
Typetura was created to make fluid typography mainstream. To do this there were two problems to solve. First, develop an implementation that is feature rich and easy to implement with CSS. Second, create a design tool that designers can use to illustrate how they want fluid typography to look.
I love a tool that tries to remove friction and make technologies easier to use.
To ensure the implementation was easy to use and understand, Typetura needed a simple, declarative syntax in vanilla CSS. This means no complicated math or Sass tricks.
Design software is constructed around fixed art boards, but there needs to be a way for designers to communicate how designs transition between sizes… Typetura is a tool that enables designers to work with a fluid canvas.
and elements. Gotta love a good ol’ HTML deep dive.
I use these on just about every blog post here on CSS-Tricks, and as I’ve suspected, I’ve basically been doing it wrong forever. My original thinking was that a figcaption was just as good as the alt attribute. I generally use it to describe the image.
<figure>
<img src="starry-night.jpg" alt="">
<figcaption>The Starry Night, a famous painting by Vincent van Gogh</figcaption>
</figure>
I intentionally left off the alt text, because the figcaption is saying what I would want to say in the alt text and I thought duplicating it would be annoying (to a screen reader user) and unnecessary. Scott says that’s bad as the empty alt text makes the image entirely undiscoverable by some screen readers and the figure is describing nothing as a result.
The correct answer, I think, is to do more work:
<figure>
<img src="starry-night.jpg" alt="An abstract painting with a weird squiggly tree thing in front of a swirling starry nighttime sky.">
<figcaption>The Starry Night, a famous painting by Vincent van Gogh</figcaption>
</figure>
It’s a good goal, and I should do better about this. It’s just laziness that gets in the way, and laziness that makes me wish there was a pattern that allowed me to write a description once that worked for both. Maybe something like Nino Ross Rodriguez just shared today where artificial intelligence can take some of the lift. But that’s kinda not the point here. The point is that you can’t write it once because and alt do different things.
Web developers and content editors alike often forget or ignore one of the most important parts of making a website accessible and SEO performant: image alt? text. You know, that seemingly small image attribute that describes an image:
<img src="/cute/sloth/image.jpg" alt="A brown baby sloth staring straight into the camera with a tongue sticking out." >
? Credit: Huffington Post
If you regularly publish content on the web, then you know it can be tedious trying to come up with descriptive text. Sure, 5-10 images is doable. But what if we are talking about hundreds or thousands of images? Do you have the resources for that?
Let’s look at some possibilities for automatically generating alt text for images with the use of computer vision and image recognition services from the likes Google, IBM, and Microsoft. They have the resources!
Reminder: What is alt text good for?
Often overlooked during web development and content entry, the alt? attribute is a small bit of HTML code that describes an image that appears on a page. It’s so inconspicuous that it may not appear to have any impact on the average user, but it has very important uses indeed:
??Web Accessibility for Screen Readers: Imagine a page with lots of images and not a single one contains alt? text. A user surfing in using a screen reader would only hear the word “image” blurted out and that’s not very helpful. Great, there’s an image, but what is it? Including alt? enables screen readers to help the visually impaired “see” what’s there and have a better understanding of the content of the page. They say a picture is worth a thousand words — that’s a thousand words of context a user could be missing.
Display text if an image does not load: The World Wide Web seems infallible and, like New York City, that it never sleeps, but flaky and faulty connections are a real thing and, if that happens, well, images tend not to load properly and “break.” Alt text is a safeguard in that it displays on the page in place of where the “broken” image is, providing users with content as a fallback.
??SEO performance: Alt text on images contributes to SEO performance as well. Though it doesn’t exactly help a site or page skyrocket to the top of the search results, it is one factor to keep in mind for SEO performance.
Knowing how important these things are, hopefully you’ll be able to include proper alt? text during development and content entry. But are your archives in good shape? Trying to come up with a detailed description for a large backlog of images can be a daunting task, especially if you’re working on tight deadlines or have to squeeze it in between other projects.
What if there was a way to apply alt? text as an image is uploaded? And! What if there was a way to check the page for missing alt? tags and automagically fill them in for us?
There are available solutions!
Computer vision (or image recognition) has actually been offered for quite some time now. Companies like Google, IBM and Microsoft have their own APIs publicly available so that developers can tap into those capabilities and use them to identify images as well as the content in them.
There are developers who have already utilized these services and created their own plugins to generate alt? text. Take Sarah Drasner’s generator, for example, which demonstrates how Azure’s Computer Vision API can be used to create alt? text for any image via upload or URL. Pretty awesome!
There’s also Automatic Alternative Text by Jacob Peattie, which is a WordPress plugin that uses the same Computer Vision API. It’s basically an addition to the workflow that allows the user to upload an image and generated alt? text automatically.
??Tools like these generally help speed-up the process of content management, editing and maintenance. Even the effort of thinking of a descriptive text has been minimized and passed to the machine!
Getting Your Hands Dirty With AI
I have managed to have played around with a few AI services and am confident in saying that Microsoft Azure’s Computer Vision produces the best results. The services offered by Google and IBM certainly have their perks and can still identify images and proper results, but Microsoft’s is so good and so accurate that it’s not worth settling for something else, at least in my opinion.
Creating your own image recognition plugin is pretty straightforward. First, head down to Microsoft Azure Computer Vision. You’ll need to login or create an account in order to grab an API key for the plugin.
Once you’re on the dashboard, search and select Computer Vision and fill in the necessary details.
Starting out
Wait for the platform to finish spinning up an instance of your computer vision. The API keys for development will be available once it’s done.
??Keys: Also known as the Subscription Key in the official documentation
Let the interesting and tricky parts begin! I will be using vanilla JavaScript for the sake of demonstration. For other languages, you can check out the documentation. Below is a straight-up copy and paste of the code and you can use to replace the placeholders.
var request = new XMLHttpRequest();
request.open('POST', 'https://[LOCATION]/vision/v1.0/describe?maxCandidates=1&language=en', true);
request.setRequestHeader('Content-Type', 'application/json');
request.setRequestHeader('Ocp-Apim-Subscription-Key', '[SUBSCRIPTION_KEY]');
request.send(JSON.stringify({ "url": "[IMAGE_URL]" }));
request.onload = function () {
var resp = request.responseText;
if (request.status >= 200 && request.status < 400) {
// Success!
console.log('Success!');
} else {
// We reached our target server, but it returned an error
console.error('Error!');
}
console.log(JSON.parse(resp));
};
request.onerror = function (e) {
console.log(e);
};
Alright, let’s run through some key terminology of the AI service.
Location: This is the subscription location of the service that was selected prior to getting the subscription keys. If you can’t remember the location for some reason, you can go to the Overview screen and find it under Endpoint.
??
Overview > Endpoint : To get the location value
??Subscription Key: This is the key that unlocks the service for our plugin use and can be obtained under Keys. There’s two of them, but it doesn’t really matter which one is used.
??Image URL: This is the path for the image that’s getting the alt? text. Take note that the images that are sent to the API must meet specific requirements:
File type must be JPEG, PNG, GIF, BMP
?File size must be less than 4MB
??Dimensions should be greater than 50px by 50px
Easy peasy
??Thanks to big companies opening their services and API to developers, it’s now relatively easy for anyone to utilize computer vision. As a simple demonstration, I uploaded the image below to Microsoft Azure’s Computer Vision API.
??From there, you could pick out the alt? text that could be potentially used for an image. How you build upon this capability is your business:
??You could create a CMS plugin and add it to the content workflow, where the alt? text is generated when an image is uploaded and saved in the CMS.
??You could write a JavaScript plugin that adds alt? text on-the-fly, after an image has been loaded with notably missing alt? text.
??You could author a browser extension that adds alt? text to images on any website when it finds images with it missing.
??You could write code that scours your existing database or repo of content for any missing alt? text and updates them or opens pull requests for suggested changes.
??Take note that these services are not 100% accurate. They do sometimes return a low confidence rating and a description that is not at all aligned with the subject matter. But, these platforms are constantly learning and improving. After all, Rome wasn’t built in a day.
Laura Worthington is one of the new generation of type designers who are rewriting the rules of type foundries. Her beautiful lettering and professionally crafted fonts have made her one of the most popular type designers working today.
One of her best-known, and most-loved type families is Samantha, a bright and cheery font family based on slick pen lettering. The consistent rhythm and the open shapes create a surprisingly readable font with a touch of 1950s glamor.
Until now, Samantha has only been suitable for a restricted set of uses. That’s because the design features fine lines, which can be lost at smaller sizes, or lower resolutions.
So we were delighted to discover Samantha Craft, a brand new reworking of Samantha that radically increases the font’s usability. Samantha Craft features the same beautiful lines as the rest of the Samantha family, but the thickness of the strokes has been carefully increased to make Samantha Craft far more versatile.
Thanks to Samantha Craft’s thicker strokes, the font can be used at smaller sizes without the details being lost. You can use Samantha Craft on lower quality paper, even newsprint. The name “Craft” is a tribute to the crafters who use die-cutting machines, and the extra thickness on the strokes makes cutting out and weeding far easier too.
With wedding season just a few months away, Samantha Craft is a great choice for those invitations. It’s also a great option for clothes labels, or even restaurant menus.
We liked Samantha Craft so much that our sister-site, MightyDeals.com, has arranged a huge deal on it. You can get Samantha Craft for just $17, that’s a 77% discount on the $75 RRP!
But that’s not all! If you buy before February 3rd, you’ll get an even mightier 84% discount, that’s the Samantha Craft font for just $12.
Not only that, but the MightyDeals deal includes Samantha Frames, an exclusive set of decorative elements to extend the font.
(This is a sponsored article.) In this tutorial, you will build a simple weather dashboard from scratch. It will be a client-end application that is neither a “Hello World” example, nor too intimidating in its size and complexity.
The entire project will be developed using tools from the Node.js + npm ecosystem. In particular, we will be heavily relying on the Dark Sky API for the data, Vue.js for all the heavy lifting, and FusionCharts for data visualization.
Prerequisites
We expect that you are familiar with the following:
HTML5 and CSS3 (we will also be using the basic features provided by Bootstrap;
JavaScript (especially ES6 way of using the language);
Node.js and npm (the basics of the environment and package management is just fine).
Apart from the ones mentioned above, it would be great if you have familiarity with Vue.js, or any other similar JavaScript framework. We don’t expect you to know about FusionCharts — it’s so easy to use that you will learn it on the fly!
Expected Learnings
Your key learnings from this project will be:
How to plan about implementing a good dashboard
How to develop applications with Vue.js
How to create data-driven applications
How to visualize data using FusionCharts
In particular, each of the sections take you a step closer to the learning goals:
Create The Project In this section, you learn about creating a project from scratch using the Vue command-line tool.
Customize The Default Project Structure The default project scaffolding that you get in the previous section is not enough; here you learn the additional stuff needed for the project from a structural point of view.
Data Acquisition And Processing This section is the meat of the project; all the critical code for acquiring and processing data from the API is showcased here. Expect to spend maximum time on this section.
Data Visualization With FusionCharts Once we have all the data and other moving parts of the project stabilized, this section is dedicated towards visualizing the data using FusionCharts and a bit of CSS.
1. The Dashboard Workflow
Before we dive into the implementation, it is important to be clear about our plan. We break our plan into four distinct aspects:
Requirements
What are our requirements for this project? In other words, what are the things that we want to showcase through our Weather Dashboard? Keeping in mind that our intended audience are probably mere mortals with simple tastes, we would like to show them the following:
Details of the location for which they want to see the weather, along with some primary information about the weather. Since there are no stringent requirements, we will figure out the boring details later. However, at this stage, it is important to note that we will have to provide the audience a search box, so that they can provide input for the location of their interest.
Graphical information about the weather of their location of interest, such as:
Temperature variation for the day of query
Highlights of today’s weather:
Wind Speed and Direction
Visibility
UV Index
Note: The data obtained from the API provides information regarding many other aspects of the weather. We choose not to use all of them for the sake of keeping the code to a minimum.
Structure
Based on the requirements, we can structure our dashboard as shown below:
Our dashboard is as good as the data we get, because there will be no pretty visualizations without proper data. There are plenty of public APIs that provide weather data — some of them are free, and some are not. For our project, we will collect data from the Dark Sky API. However, we will not be able to poll the API endpoint from the client end directly. Don’t worry, we have a workaround that will be revealed just at the right time! Once we get the data for the searched location, we will do some data processing and formatting — you know, the type of technicalities that helps us pay the bills.
Visualization
Once we get clean and formatted data, we plug it in to FusionCharts. There are very few JavaScript libraries in the world as capable as FusionCharts. Out of the vast number of offerings from FusionCharts, we will use only a few — all written in JavaScript, but works seamlessly when integrated with the Vue wrapper for FusionCharts.
Armed with the bigger picture, let’s get our hands dirty — it’s time to make things concrete! In the next section, you will create the basic Vue project, on top of which we will build further.
2. Creating The Project
To create the project, execute the following steps:
Install Node.js + npm (If you have Node.js installed on your computer, skip this step.) Node.js comes with npm bundled with it, so you don’t need to install npm separately. Depending on the operating system, download and install Node.js according to the instructions given here.
Once installed, it’s probably a good idea to verify if the software is working correctly, and what are their versions. To test that, open the command-line/terminal and execute the following commands:
node --version
npm --version
Install packages with npm Once you have npm up and running, execute the following command to install the basic packages necessary for our project.
npm install -g vue@2 vue-cli@2
Initialize project scaffolding with vue-cli Assuming that the previous step has gone all well, the next step is to use the vue-cli — a command-line tool from Vue.js, to initialize the project. To do that, execute the following:
Initialize the scaffolding with webpack-simple template.
vue init webpack-simple vue_weather_dashboard
You will be asked a bunch of questions — accepting the defaults for all but the last question will be good enough for this project; answer N for the last one.
Keep in mind that although webpack-simple is excellent for quick prototyping and light application like ours, it is not particularly suited for serious applications or production deployment. If you want to use any other template (although we would advise against it if you are a newbie), or would like to name your project something else, the syntax is:
vue init [template-name] [project-name]
Navigate to the directory created by vue-cli for the project.
cd vue_weather_dashboard
Install all the packages mentioned in the package.json, which has been created by the vue-cli tool for the webpack-simple template.
npm install
Start the development server and see your default Vue project working in the browser!
npm run dev
If you are new to Vue.js, take a moment to savor your latest achievement — you have created a small Vue application and its running at localhost:8080!
Brief Explanation Of The Default Project Structure
It’s time to take a look at the structure inside the directory vue_weather_dashboard, so that you have an understanding of the basics before we start modifying it.
Although it might be tempting to skip getting familiar with the default files and directories, if you are new to Vue, we strongly recommend at least taking a look at the contents of the files. It can be a good educational session and trigger questions that you should pursue on your own, especially the following files:
package.json, and just a glance at its cousin package-lock.json
webpack.config.js
index.html
src/main.js
src/App.vue
A brief explanation of each of the files and directories shown in the tree diagram are given below:
README.md
No prize for guessing — it is primarily for humans to read and understand the steps necessary for creating the project scaffolding.
node_modules/
This is the directory where npm downloads the packages necessary for kickstarting the project. The information about the packages necessary are available in the package.json file.
package.json
This file is created by the vue-cli tool based on the requirements of the webpack-simple template, and contains information about the npm packages (including with their versions and other details) that must be installed. Take a hard look at the content of this file — this is where you should visit and perhaps edit to add/delete packages necessary for the project, and then run npm install. Read more about package.jsonhere.
package-lock.json
This file is created by npm itself, and is primarily meant for keeping a log of things that npm downloaded and installed.
webpack.config.js
This a JavaScript file that contains the configuration of webpack — a tool that bundles different aspects of our project together (code, static assets, configuration, environments, mode of use, etc.), and minifies before serving it to the user. The benefit is that all things are tied together automatically, and the user experience enhances greatly because of the improvement in the application’s performance (pages are served quickly and loads faster on the browser). As you might encounter later, this is the file that needs to be inspected when something in the build system does not works the way it is intended to be. Also, when you want to deploy the application, this is one of the key files that needs to be edited (read more here).
index.html
This HTML file serves as the matrix (or you can say, template) where data and code is to be embedded dynamically (that’s what Vue primarily does), and then served to the user.
src/main.js
This JavaScript file contains code that primarily manages top/project level dependencies, and defines the topmost level Vue component. In short, it orchestrates the JavaScript for the entire project, and serves as the entry point of the application. Edit this file when you need to declare project-wide dependencies on certain node modules, or you want something to be changed about the topmost Vue component in the project.
src/App.vue
In the previous point, when we were talking about the “topmost Vue component”, we were essentially talking about this file. Each .vue file in the project is a component, and components are hierarchically related. At the start, we have only one .vue file, i.e. App.vue, as our only component. But shortly we will add more components to our project (primarily following the structure of the dashboard), and link them in accordance to our desired hierarchy, with App.vue being the ancestor of all. These .vue files will contain code in a format that Vue wants us to write. Don’t worry, they are JavaScript code written maintaining a structure that can keep us sane and organized. You have been warned — by the end of this project, if you are new to Vue, you may get addicted to the template — script — style way of organizing code!
Now that we have created the foundation, it’s time to:
Modify the templates and tweak the configuration files a bit, so that the project behaves just the way we want.
Create new .vue files, and implement the dashboard structure with Vue code.
We will learn them in the next section, which is going to be a bit long and demands some attention. If you need caffeine or water, or want to discharge — now is the time!?
3. Customizing The Default Project Structure
It’s time to tinker with the foundation that the scaffolded project has given us. Before you start, ensure that the development server provided by webpack is running. The advantage of running this server continuously is that any changes you make in the source code — one you save it and refresh the web page — it gets immediately reflected on the browser.
If you want to start the development server, just execute the following command from the terminal (assuming your current directory is the project directory):
npm run dev
In the following sections, we will modify some of the existing files, and add some new files.
It will be followed by brief explanations of the content of those files, so that you have an idea of what those changes are meant to do.
