Original Source: https://www.sitepoint.com/build-a-simple-rest-api-with-node-and-oauth-2-0/

This article was originally published on the Okta developer blog. Thank you for supporting the partners who make SitePoint possible.

JavaScript is used everywhere on the web – nearly every web page will include at least some JavaScript, and even if it doesn’t, your browser probably has some sort of extension that injects bits of JavaScript code on to the page anyway. It’s hard to avoid in 2018.

JavaScript can also be used outside the context of a browser, for anything from hosting a web server to controlling an RC car or running a full-fledged operating system. Sometimes you want a couple of servers to talk to each other, whether on a local network or over the internet.

Today, I’ll show you how to create a REST API using Node.js, and secure it with OAuth 2.0 to prevent unwarranted requests. REST APIs are all over the web, but without the proper tools require a ton of boilerplate code. I’ll show you how to use a couple of amazing tools that make it all a breeze, including Okta to implement the Client Credentials Flow, which securely connects two machines together without the context of a user.

Build Your Node Server

Setting up a web server in Node is quite simple using the Express JavaScript library. Make a new folder that will contain your server.

$ mkdir rest-api

Node uses a package.json to manage dependencies and define your project. To create one, use npm init, which will ask you some questions to help you initialize the project. For now, you can use standard JS to enforce a coding standard, and use that as the tests.

$ cd rest-api

$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (rest-api)
version: (1.0.0)
description: A parts catalog
entry point: (index.js)
test command: standard
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/Braden/code/rest-api/package.json:

{
“name”: “rest-api”,
“version”: “1.0.0”,
“description”: “A parts catalog”,
“main”: “index.js”,
“scripts”: {
“test”: “standard”
},
“author”: “”,
“license”: “ISC”
}

Is this OK? (yes)

The default entry point is index.js, so you should create a new file by that name. The following code will get you a really basic server that doesn’t really do anything but listens on port 3000 by default.

index.js

const express = require(‘express’)
const bodyParser = require(‘body-parser’)
const { promisify } = require(‘util’)

const app = express()
app.use(bodyParser.json())

const startServer = async () => {
const port = process.env.SERVER_PORT || 3000
await promisify(app.listen).bind(app)(port)
console.log(`Listening on port ${port}`)
}

startServer()

The promisify function of util lets you take a function that expects a callback and instead will return a Promise, which is the new standard as far as handling asynchronous code. This also lets us use the relatively new async/await syntax and make our code look much prettier.

In order for this to work, you need to install the dependencies that you require at the top of the file. Add them using npm install. This will automatically save some metadata to your package.json file and install them locally in a node_modules folder.

Note: You should never commit node_modules to source control because it tends to become bloated quickly, and the package-lock.json file will keep track of the exact versions you used to that if you install this on another machine they get the same code.

$ npm install express@4.16.3 util@0.11.0

For some quick linting, install standard as a dev dependency, then run it to make sure your code is up to par.

$ npm install –save-dev standard@11.0.1
$ npm test

> rest-api@1.0.0 test /Users/bmk/code/okta/apps/rest-api
> standard

If all is well, you shouldn’t see any output past the > standard line. If there’s an error, it might look like this:

$ npm test

> rest-api@1.0.0 test /Users/bmk/code/okta/apps/rest-api
> standard

standard: Use JavaScript Standard Style (https://standardjs.com)
standard: Run `standard –fix` to automatically fix some problems.
/Users/Braden/code/rest-api/index.js:3:7: Expected consistent spacing
/Users/Braden/code/rest-api/index.js:3:18: Unexpected trailing comma.
/Users/Braden/code/rest-api/index.js:3:18: A space is required after ‘,’.
/Users/Braden/code/rest-api/index.js:3:38: Extra semicolon.
npm ERR! Test failed. See above for more details.

Now that your code is ready and you have installed your dependencies, you can run your server with node . (the . says to look at the current directory, and then checks your package.json file to see that the main file to use in this directory is index.js):

$ node .

Listening on port 3000

To test that it’s working, you can use the curl command. There are no endpoints yet, so express will return an error:

$ curl localhost:3000 -i
HTTP/1.1 404 Not Found
X-Powered-By: Express
Content-Security-Policy: default-src ‘self’
X-Content-Type-Options: nosniff
Content-Type: text/html; charset=utf-8
Content-Length: 139
Date: Thu, 16 Aug 2018 01:34:53 GMT
Connection: keep-alive

<!DOCTYPE html>
<html lang=”en”>
<head>
<meta charset=”utf-8″>
<title>Error</title>
</head>
<body>
<pre>Cannot GET /</pre>
</body>
</html>

Even though it says it’s an error, that’s good. You haven’t set up any endpoints yet, so the only thing for Express to return is a 404 error. If your server wasn’t running at all, you’d get an error like this:

$ curl localhost:3000 -i
curl: (7) Failed to connect to localhost port 3000: Connection refused

Build Your REST API with Express, Sequelize, and Epilogue

Now that you have a working Express server, you can add a REST API. This is actually much simpler than you might think. The easiest way I’ve seen is by using Sequelize to define your database schema, and Epilogue to create some REST API endpoints with near-zero boilerplate.

You’ll need to add those dependencies to your project. Sequelize also needs to know how to communicate with the database. For now, use SQLite as it will get us up and running quickly.

npm install sequelize@4.38.0 epilogue@0.7.1 sqlite3@4.0.2

Create a new file database.js with the following code. I’ll explain each part in more detail below.

database.js

const Sequelize = require(‘sequelize’)
const epilogue = require(‘epilogue’)

const database = new Sequelize({
dialect: ‘sqlite’,
storage: ‘./test.sqlite’,
operatorsAliases: false
})

const Part = database.define(‘parts’, {
partNumber: Sequelize.STRING,
modelNumber: Sequelize.STRING,
name: Sequelize.STRING,
description: Sequelize.TEXT
})

const initializeDatabase = async (app) => {
epilogue.initialize({ app, sequelize: database })

epilogue.resource({
model: Part,
endpoints: [‘/parts’, ‘/parts/:id’]
})

await database.sync()
}

module.exports = initializeDatabase

Now you just need to import that file into your main app and run the initialization function. Make the following additions to your index.js file.

index.js

@@ -2,10 +2,14 @@ const express = require(‘express’)
const bodyParser = require(‘body-parser’)
const { promisify } = require(‘util’)

+const initializeDatabase = require(‘./database’)
+
const app = express()
app.use(bodyParser.json())

const startServer = async () => {
+ await initializeDatabase(app)
+
const port = process.env.SERVER_PORT || 3000
await promisify(app.listen).bind(app)(port)
console.log(`Listening on port ${port}`)

You can now test for syntax errors and run the app if everything seems good:

$ npm test && node .

> rest-api@1.0.0 test /Users/bmk/code/okta/apps/rest-api
> standard

Executing (default): CREATE TABLE IF NOT EXISTS `parts` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `partNumber` VARCHAR(255), `modelNu
mber` VARCHAR(255), `name` VARCHAR(255), `description` TEXT, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL);
Executing (default): PRAGMA INDEX_LIST(`parts`)
Listening on port 3000

In another terminal, you can test that this is actually working (to format the JSON response I use a json CLI, installed globally using npm install –global json):

$ curl localhost:3000/parts
[]

$ curl localhost:3000/parts -X POST -d ‘{
“partNumber”: “abc-123”,
“modelNumber”: “xyz-789”,
“name”: “Alphabet Soup”,
“description”: “Soup with letters and numbers in it”
}’ -H ‘content-type: application/json’ -s0 | json
{
“id”: 1,
“partNumber”: “abc-123”,
“modelNumber”: “xyz-789”,
“name”: “Alphabet Soup”,
“description”: “Soup with letters and numbers in it”,
“updatedAt”: “2018-08-16T02:22:09.446Z”,
“createdAt”: “2018-08-16T02:22:09.446Z”
}

$ curl localhost:3000/parts -s0 | json
[
{
“id”: 1,
“partNumber”: “abc-123”,
“modelNumber”: “xyz-789”,
“name”: “Alphabet Soup”,
“description”: “Soup with letters and numbers in it”,
“createdAt”: “2018-08-16T02:22:09.446Z”,
“updatedAt”: “2018-08-16T02:22:09.446Z”
}
]

What’s Going On Here?

Feel free to skip this section if you followed along with all that, but I did promise an explanation.

The Sequelize function creates a database. This is where you configure details, such as what dialect of SQL to use. For now, use SQLite to get up and running quickly.

const database = new Sequelize({
dialect: ‘sqlite’,
storage: ‘./test.sqlite’,
operatorsAliases: false
})

Once you’ve created the database, you can define the schema for it using database.define for each table. Create a table called parts with a few useful fields to keep track of parts. By default, Sequelize also automatically creates and updates id, createdAt, and updatedAt fields when you create or update a row.

const Part = database.define(‘parts’, {
partNumber: Sequelize.STRING,
modelNumber: Sequelize.STRING,
name: Sequelize.STRING,
description: Sequelize.TEXT
})

Epilogue requires access to your Express app in order to add endpoints. However, app is defined in another file. One way to deal with this is to export a function that takes the app and does something with it. In the other file when we import this script, you would run it like initializeDatabase(app).

Epilogue needs to initialize with both the app and the database. You then define which REST endpoints you would like to use. The resource function will include endpoints for the GET, POST, PUT, and DELETE verbs, mostly automagically.

To actually create the database, you need to run database.sync(), which returns a Promise. You’ll want to wait until it’s finished before starting your server.

The module.exports command says that the initializeDatabase function can be imported from another file.

const initializeDatabase = async (app) => {
epilogue.initialize({ app, sequelize: database })

epilogue.resource({
model: Part,
endpoints: [‘/parts’, ‘/parts/:id’]
})

await database.sync()
}

module.exports = initializeDatabase

Secure Your Node + Express REST API with OAuth 2.0

Now that you have a REST API up and running, imagine you’d like a specific application to use this from a remote location. If you host this on the internet as is, then anybody can add, modify, or remove parts at their will.

To avoid this, you can use the OAuth 2.0 Client Credentials Flow. This is a way of letting two servers communicate with each other, without the context of a user. The two servers must agree ahead of time to use a third-party authorization server. Assume there are two servers, A and B, and an authorization server. Server A is hosting the REST API, and Server B would like to access the API.

Server B sends a secret key to the authorization server to prove who they are and asks for a temporary token.
Server B then consumes the REST API as usual but sends the token along with the request.
Server A asks the authorization server for some metadata that can be used to verify tokens.
Server A verifies the Server B’s request.

If it’s valid, a successful response is sent and Server B is happy.
If the token is invalid, an error message is sent instead, and no sensitive information is leaked.

Create an Authorization Server

This is where Okta comes into play. Okta can act as an authorization server to allow you to secure your data. You’re probably asking yourself “Why Okta? Well, it’s pretty cool to build a REST app, but it’s even cooler to build a secure one. To achieve that, you’ll want to add authentication so users have to log in before viewing/modifying groups. At Okta, our goal is to make identity management a lot easier, more secure, and more scalable than what you’re used to. Okta is a cloud service that allows developers to create, edit, and securely store user accounts and user account data, and connect them with one or multiple applications. Our API enables you to:

Authenticate and authorize your users
Store data about your users
Perform password-based and social login
Secure your application with multi-factor authentication
And much more! Check out our product documentation

If you don’t already have one, sign up for a forever-free developer account, and let’s get started!

After creating your account, log in to your developer console, navigate to API, then to the Authorization Servers tab. Click on the link to your default server.

From this Settings tab, copy the Issuer field. You’ll need to save this somewhere that your Node app can read. In your project, create a file named .env that looks like this:

.env

ISSUER=https://{yourOktaDomain}/oauth2/default

The value for ISSUER should be the value from the Settings page’s Issuer URI field.

Note: As a general rule, you should not store this .env file in source control. This allows multiple projects to use the same source code without needing a separate fork. It also makes sure that your secure information is not public (especially if you’re publishing your code as open source).

Next, navigate to the Scopes tab. Click the Add Scope button and create a scope for your REST API. You’ll need to give it a name (e.g. parts_manager) and you can give it a description if you like.

You should add the scope name to your .env file as well so your code can access it.

.env

ISSUER=https://{yourOktaDomain}/oauth2/default
SCOPE=parts_manager

Now you need to create a client. Navigate to Applications, then click Add Application. Select Service, then click Next. Enter a name for your service, (e.g. Parts Manager), then click Done.

The post Build a Simple REST API with Node and OAuth 2.0 appeared first on SitePoint.

Original Source: https://www.sitepoint.com/growth-hacking-data/

No data? No problem. You can growth hack your way to success in seven steps.

Whether you’re pre-launch or ready to scale, data can hold the key to your business’ growth. Even if you don’t have much data about your customers or product yet, you can still use data to growth hack your business by following these seven steps.

1. Define your business objectives

Before you can shoot for the stars you need to be clear about what you’re trying to achieve. While this is often easier than it sounds, it’s a crucial step because your goal will drive your strategy.

According to Simon Mathonnet, Chief of Digital Strategy for Splashbox, it’s important to translate your objective into something practical. For example, rather than saying your goal is to grow your business, it should be more specific — like you want to quit your job so you can focus full-time on the company, or you want to raise a Series A investment round.

2. Make your objectives measurable

Once you’ve defined your objective, it then needs to be translated into something that you can track. A good way to do this is to make it SMART. This stands for:

Specific: Make the objective clear and easy to grasp.
Measurable: Set a quantitative goal that can be measured.
Achievable: Get buy-in from your team and give them (and yourself) an incentive by having an objective that’s within reach.
Relevant: Your goal needs to make sense and be in line with what the business is trying to achieve.
Time: Be clear about when the objective needs to be achieved. This will give you something to look forward to.

The SMART objective for the two objectives above may be:

Quit your job to focus on your startup = Generate $X of revenue per month for three consecutive months.
Series A capital raising = Retain Y active users for three months before approaching investors.

3. Create a hypothesis

Once you’ve defined your goal you need to find a way to get closer to achieving it. One way to do this is to create a hypothesis that you can implement and test quickly. The hypothesis is essentially an educated guess or hunch based on what you know about your product or service and customers.

For example, if your objective is to grow revenue, then your hypothesis might be that people who look at three or more products on your website are more likely to purchase. This means you need to find a way to get people who visit your site to look at three or more products because you believe this will increase your revenue.

4. Collect data

To be able to test and measure your hypothesis you need to have data. The data sets a baseline — so you know your starting point — and measures your results. The type of data that you need will depend on your hypothesis.

If you’re pre-launch, you probably don’t have much customer data yet. Most startups also struggle with data because of their uniqueness — traditional, quantifiable data sources like market research may not have insights for your product or market segment. While it can be expensive to commission market research, thankfully there’s a plethora of technology that’s relatively inexpensive that can help you mine information and generate new data.

Some ways you can collect data include:

Google Analytics: This is useful if you have had many visitors to your site. It collects data on what interactions people have on your website, like how long they spent on your site, what pages are the most popular, what search terms they used and what links they clicked.
PoweredLocal: If you have a brick and mortar shopfront, this platform lets you collect information about your customers by offering them complimentary Wi-Fi access. When customers use social media or email to sign onto your network, you can find out who they are, what they like, and potentially sign them up to your newsletter or offers.
Online reviews: Review sites like Yelp or TripAdvisor serve two purposes. They let people who are looking for your product or service hear what you’re like directly from your customers, and they provide a way for customers to give you feedback. This feedback is data that you can use to identify opportunities to improve your customer experience.
HotJar: This heatmap tool lets you see how people use and respond to messages on your site by showing what they engage with. Unlike Google Analytics, you don’t need too many visitors to your site to start seeing what is attracting or repelling your customers.
Social Media: Research social media channels to see what customers are talking about. This may be either on your own social media pages or your competitors’. Social media platforms like Facebook and Twitter also have analytics tools that are often available for free. These can show you demographic and engagement information about your audience.
LeadChat: Use a live chat function on your website to get direct input from your customers. Find out your customer demographic and see what questions they ask to determine what they’re interested in or are struggling with.
Events and pitch nights: Collect anecdotal data by talking to potential customers, peers and competitors. You can find them at industry events, pitch nights and conferences.

The post Seven Steps for Growth Hacking Your Business with Data appeared first on SitePoint.

Original Source: http://feedproxy.google.com/~r/tympanus/~3/fq3B2HXo4oM/

Our Sponsor
CONNECT TECH Atlanta’s web/mobile dev conference

October 17-19 Atlanta. A World Class JavaScript, React, Angular, Vue, Web, Design Conference. 1200 attendees, 120 sessions, 12 workshops.

Learn more

What is Modular CSS?

An in-depth exploration of Modular CSS. By Scott Vandehey.

Read it

Responsive Images

Mat Marquis takes a look back at how responsive images evolved.

Read it

Inside look at modern web browser (part 4)

Mariko Kosaka concludes her article series on how Chrome handles code to display a website.

Read it

GraphQLEditor

With GraphQLEditor you can create visual diagrams without writing any code.

Check it out

The 9am Rush Hour

The first article in a series where Paul Lewis and Surma think out loud about the challenges they see in modern web development.

Read it

ColorBox

Colorbox is a tool to produce color sets. Made by the Lyft design team.

Check it out

Why I’m done with Chrome

Read why Matthew Green has had enough of Google Chrome’s violation of user privacy. Read the Hacker News discussion here.

Read it

Interplanetary Postal Service

A lunar lander type game with complex fluid dynamics as an entry to the 2018 js13kgames competition.

Check it out

Dark Patterns And Other Design No-Nos For Mobile

Suzanne Scacca warns against using dark patterns on mobile sites.

Read it

Freebie: Autumn Kawaii Icon Set

A set of 50 gorgeous looking autumn themed icons.

Get it

Understanding JavaScript’s Prototypal Inheritance

An article by Rajat S on how prototypal inheritance works in JavaScript.

Read it

Free Font: Marker Mark

Vlad Cristea designed this handwritten SVG font.

Check it out

Underrun – Making of

Read about he making of Underrun, a twin stick shooter using WebGL.

Read it

Variable Font Experiments

Mark Frömberg’s fantastic animated variable font experiments.

Check it out

Responsive animated progress bar to donut

These progress bars will animate to doughnuts when the screen gets smaller. By Mikael Ainalem.

Check it out

Werner’s Nomenclature of Colours

A recreation of the original 1821 color guidebook with new cross references, photographic examples, and posters designed by Nicholas Rougeux.

Check it out

#CodePenChallenge: HTTP Status 500

Check out all the great demos of Codepen’s HTTP Status 500 challenge.

Check it out

Ripple Mouse (with plasma)

A great demo of interactive plasma by Liam Egan.

Check it out

From Our Blog
Grid Layout with Scrollable Content View

A Masonry-powered grid layout with a motion hover effect on the grid items and a scrollable content view.

Check it out

Collective #453 was written by Pedro Botelho and published on Codrops.

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/PO4IF2JXRSQ/best-black-friday-deals-2018

Black Friday 2018 is coming around again fast. It's a fantastic time for designers and artists to make massive savings on creative hardware, software and resources – but the sheer volume of Black Friday deals on offer, and the speed at which they come and go, can be utterly overwhelming.

That's why we'll be curating the very best Black Friday deals in 2018 for designers, artists and creatives right here – so bookmark this page and check back in closer to the time.

In the meantime, there are a few things you can do now to make sure you're ready to bag a bargain in November. From the dates you need in your diary through to pro tips on how to get the best Black Friday deals as a designer, artist or creative, here’s everything you need to know about Black Friday 2018…

When is Black Friday 2018?

This year, Black Friday falls on 23 November 2018, with Cyber Monday following on the 26 November. Always held the day after Thanksgiving, Black Friday marks the unofficial beginning of the Christmas shopping season. 

Traditionally Black Friday was a one-day brick-and-mortar juggernaut of sales, with Cyber Monday later conceived by savvy marketeers to extend the sales period online. These days, Black Friday is of course a huge online event as well. 

In the last few years, the spending bonanza has morphed into a 'Black November', with many major retailers leaking decent money-saving deals throughout the month. Amazon, for example, officially opened its Black Friday Deals Store on the 17 November in 2017, a week before Black Friday started. We also saw plenty of deals creeping through before that – and a lot of rock-bottom deals in the days after Cyber Monday, too. 

So make sure you check back into this page from early November to see what's on offer.

Black Friday: where to find the biggest savings

So where to look for real bargains? Well, the best Black Friday deals on creative hardware and software tend to come from third-party retailers – rather than directly from manufacturers like Apple or Wacom. That said, Microsoft slashed the cost of its Surface family of tablets for Black Friday 2017, and we saw big tech bargains on the Dell website too.

Some of the biggest savings last year across the board, however, came from Amazon and eBay. Certainly this is where you need to be if you're in the market for a new drawing tablet – and there were fantastic bargains to be found on desktops, laptops, 4K monitors, computer mice, keyboards and more.

Whether you’re interested in perusing Black Friday deals directly on the websites of the most reputable retailers, sign-up for early Black Friday alerts or do some early product research, here are the links you need… 

Black Friday deals 2018: retail links

US: Black Friday retail links

Amazon | eBay | Newegg | Jet Black | Microsoft | Dell | Walmart | B&H Photo | GameStop | Toys R Us

UK: Black Friday retail links

Amazon | eBay | Microsoft | Dell |  Very.co.uk | John Lewis | Currys | Argos | Tesco | AO.com | Carphone Warehouse | Mobiles.co.uk | ASOS

How to get the best Black Friday deals in 2018

We’ll be curating the very best Black Friday deals for creatives right here again this year, so bookmark this page and keep checking back in November. But there are some other pro tips you can follow for bagging big Black Friday bargains, too.

01. Do your research

The best way to avoid getting a bad deal is to do your research first. You need to be knowledgeable about the product – and its normal retail price. 

Draw up a list of items you might like to purchase over Black Friday, read the reviews, research the best manufacturers, and make sure you know the difference between a good and bad version of that product.

02. Compare prices

It’s always a good idea to compare prices, so use price-comparison internet shopping sites like PriceGrabber.com for insight where you’re looking at product prices. 

03. Check the extras

And make sure you check the specs: are you looking at a low or high-specced product for this price? Does it come with accessories? What about post and packaging charges?

04. Consider payment options

Another tip is to think about how you’re paying. While we don’t suggest racking up huge credit cards bills with big interest rates, many credit cards do offer benefits like free warranties, return protection and sale price protection – which are worth bearing in mind. 

05. Get an Amazon Prime subscription

Prime users (including all those on a free trial) are offered an exclusive 30-minute early access period to all Amazon Lightning Deals. If you don't already have one, an Amazon Prime subscription will set you back £79/$99 per year. 

06. Know the best days to buy

Adobe has crunched the numbers to put together a handy guide revealing the best days to buy different products, and also which products are more likely to run out on which days.

Apparently, Thanksgiving is the best time to grab a bargain on computers – you’re likely to save 16 per cent, on average – but it’s also the day popular tablets and televisions are most likely to be out of stock.

Black Friday, meanwhile, is the best day to save on tablets and televisions (on average 24 per cent), with computers most likely to be out of stock. 

Today’s best deals on the best creative kit

Can't hang on until Black Friday to pick up a hot deal? No problem. There are plenty of fantastic bargains to be found on creative hardware, software and resources right now. 

We're tracking the months' best deals in the following articles, and you can scroll down for the day's best deals on our favourite creative products…

The best Macbook and Macbook Pro deals The best Microsoft Surface dealsThe best Dell XPS dealsThe best cheap laptop dealsThe best Wacom tablet dealsThe best Adobe deals30 books every graphic designer should read

Related articles:

The best laptop deals for designersThe best Macbook and MacBook Pro dealsThe best Wacom tablet deals

Original Source: https://www.webdesignerdepot.com/2018/09/grid-vs-flexbox-which-should-you-choose/

CSS Grid and CSS Flexbox are complimentary web layout technologies that have been hotly anticipated for years. However, despite some superficial similarities they are actually used for very different tasks; they each solve a very different set of problems.

In an ideal scenario, you may find that you employ both for different layout tasks. In this post we’ll look at their differences, look at how they solve various layout problems, and help you choose which (if either) is the right solution for your problem.

Grid is Container-Based, Flexbox is Content-Based

In flexbox layout, the size of a cell (flex-item) is defined inside the flex-item itself, and in the grid layout, the size of a cell (grid-item) is defined inside the grid-container.

Confusing?

Let’s look at an example, here’s the HTML to create a row of elements:

<div class=”row”>
<div>1</div>
<div>2</div>
<div>3</div>
<div>4</div>
</div>

And we style this using flexbox like so:

.row {
margin: 20px auto;
max-width: 300px;
display: flex;
}
.row > div {
border: 1px dashed gray;
flex: 1 1 auto; /* Size of items defined inside items */
text-align: center;
padding: 12px;
}

We defined the size of the cells inside the flex-item by setting flex: 1 1 auto;. The flex property is shorthand to set flex-grow, flex-shrink, and flex-basis properties in one statement; its default value is 0 1 auto. Notice the “row” div is the flex-container, and we don’t set the size of the items there. We set the size inside the flex-item.

When previewed in a browser we get a row of boxes, as you would expect:

Now let’s see how we can generate the same output using grid:

.row {
margin: 20px auto;
max-width: 300px;
display: grid;
grid-template-columns: 1fr 1fr 1fr 1fr; /* Size of items defined inside container */
}
.row div {
border: 1px dashed gray;
text-align: center;
padding: 12px;
}

Above code will give us exactly the same output.

Notice, now we are defining the cell’s size using grid-template-columns inside the grid-container (.row), not the grid-item.

This is an important difference. It shows that the flexbox layout is calculated after its content is loaded whereas the grid layout is calculated regardless of the content inside it. So, if possible, avoid using flexbox to build the overall layout of your website.

Grid Has a “Gap” Property, Flexbox Doesn’t

You can argue that a major difference between flexbox and grid is that in the latter we can create gutters between grid-items using grid-column-gap, like so:

In order to achieve the same result in flexbox we would have to use padding and nested containers, or increase the width of the flex-container and use the justify-content property to spread the flex-items.

We have to take a circuitous route in flexbox because it doesn’t have a gap property. However, it is on the way; the CSS Box Alignment Module 3 contains CSS features relating to alignment of boxes in all layout modes: block layout, table layout, flex layout, and grid layout. The Box Alignment module collects properties from flexbox, grid, and multi-column which can be used consistently across all the layout models. Eventually we’ll be able to add gaps with row-gap and column-gap properties, but not yet.

Flexbox is One Dimensional, Grid is Two Dimensional

We’ve been arranging elements as rows and columns on the web since we used tables for layout. Both flexbox and grid are based on this concept. Flexbox is best for arranging elements in either a single row, or a single column. Grid is best for arranging elements in multiple rows and columns.

In other words, Flexbox is one dimensional, and Grid is two dimensional. Let’s look at a commonly used one dimensional layout – the social share buttons:

All the elements are in a single row. We can implement this using Flexbox like this:

<ul class=”social-icons”>
<li><a href=”#”><i class=”fab fa-facebook-f”></i></a></li>
<li><a href=”#”><i class=”fab fa-twitter”></i></a></li>
<li><a href=”#”><i class=”fab fa-instagram”></i></a></li>
<li><a href=”#”><i class=”fab fa-github”></i></a></li>
<li><a href=”#”><i class=”fas fa-envelope”></i></a></li>
<li><a href=”#”><i class=”fas fa-rss”></i></a></li>
</ul>

.social-icons {
display: flex;
list-style: none;
justify-content: space-around;
}

The justify-content property determines how the extra space of the flex-container is distributed to the flex-items. The space-around value distributes the space in such a way that the flex-items get placed evenly with equal amount of space around them.

Next, let’s take a look at a commonly used 2-dimensional layout:

We can’t implement this layout with a single row or a single column, we need multiple rows and columns to do that, and that’s where we use CSS Grids. Let’s make it using CSS Grid:

<div class=”container”>
<header>Header</header>
<main>Main</main>
<aside>Aside</aside>
<footer>Footer</footer>
</div>

and the CSS:

.container {
max-width: 800px;
margin: 2em auto;
display: grid;
grid-template-columns: 3fr 1fr;
grid-template-rows: repeat(3,auto);
grid-gap: 1rem;
}

.container header {
grid-area: 1/1/2/3;
}

.container main {
grid-area: 2/1/3/2;
}

.container aside {
grid-area: 2/2/3/3;
}

.container footer {
grid-area: 3/1/4/3;
}

.container > * {
background-color: #ddd;
padding: 1rem;
}

We are creating two columns using the grid-template-columns property, and three rows using grid-template-rows property. The repeat() function creates 3 rows with auto height.

Then, inside the grid-items (header, main, aside, and footer) we define how much area those grid-items will cover using the grid-area property.

Flexbox Wraps vs Grid Wraps

When the total width of items inside the container is greater than the width of the container, in that case both the layout models have the option to wrap the items to a new row. However, the way both handle wrapping is different.

Let’s look at that difference by building an sample layout. Create two rows and place 6 divs inside each row:

<h2>Flexbox</h2>
<div class=”row-flex”>
<div>1 2 3 4 5 6 7 8 9 0</div>
<div>2</div>
<div>3</div>
<div>4</div>
<div>5</div>
<div>6</div>
</div>

<h2>Grid</h2>
<div class=”row-grid”>
<div>1 2 3 4 5 6 7 8 9 0</div>
<div>2</div>
<div>3</div>
<div>4</div>
<div>5</div>
<div>6</div>
</div>

Now, we will use Flexbox to layout the first row and Grid for second:

/* Flexbox row styles */
.row-flex {
margin: 40px auto;
max-width: 600px;
display: flex;
flex-wrap: wrap;
}
.row-flex div {
border: 1px dashed gray;
flex: 1 1 100px;
text-align: center;
padding: 12px;
}
/* Grid row styles */
.row-grid {
margin: 40px auto;
max-width: 600px;
display: grid;
grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
}
.row-grid div {
border: 1px dashed gray;
text-align: center;
padding: 12px;
}

For the first row, we are using flex: 1 1 100px to give the flex-items a base width of 100px and allow it to grow and shrink.

We are also enabling wrapping of flex-items inside the flex-container by setting the flex-wrap property to wrap, its default value is nowrap.

For the second row, we are using the grid-template-columns property to create columns with minimum width 100px set by the minmax() function. We are using repeat() function to create columns repeatedly.

You can see the beauty of Grid and Flexbox lies in the ability to stretch and squeeze the items based on the amount of space available. Flexbox achieves this using flex-grow and flex-shrink properties, and Grid achieves this using a combination of minmax and auto-fill functions inside the grid-template-columns property.

However, look carefully at the cell 5 and cell 6 as they are pushed down. In the case of Flexbox, the cell 5 and 6 are not the same size as other cells when pushed down. While in case of Grid, they retain the same size as all other cells in the grid.

This happens because when a flex-item is wrapped and pushed in a new row, the Flexbox layout algorithm treats it as a part of a different flex-container. Hence the pushed item loses its context.

This behavior could be used in some use cases, for example, an email subscriber form:

Let’s build this subscriber form:

<div class=”subscriber-form-container”>
<form>
<input type=”email” placeholder=”Email Address”>
<input type=”text” placeholder=”Name”>
<input type=”submit” value=”Subscribe”>
</form>
</div>

and give it some styles in our CSS:

.subscriber-form-container {
max-width: 650px;
margin: 40px auto;
border: 1px dashed gray;
box-sizing: border-box;
}
.subscriber-form-container form {
display: flex;
flex-wrap: wrap;
}
.subscriber-form-container form input {
margin: 6px;
padding: 0.4rem;
box-sizing: border-box;
}
.subscriber-form-container form input{
flex: 1 1 150px;
}
.subscriber-form-container form input[type=”email”] {
flex: 2 1 300px;
}

The flex property is the shorthand for three properties: flex-grow, flex-shrink, and flex-basis. We want the width of the “email” field to be double the width of other two input elements, and we achieve this by using its “flex-grow” and “flex-basis”.

The “flex-grow” property of input elements is set to “1”, but that of email input element is set to 2. So, when there is extra space available, the email input element will grow twice compared to other input elements.

Flexbox outperforms Grid in this use case. Yes, you could use some hack to get CSS Grid replicate this behavior using minmax() function, but Flexbox is well-suited for this kind of single dimensional layouts.

However, if you want a multi-dimensional layout with the wrapped elements maintaining their widths, for example, an image gallery, then Grid is the best choice:

One more thing, did you notice we are not using any media queries here. That’s because Flexbox and Grid layouts are built on concept of responsiveness and hence reduce the use of Media Queries.

Will CSS Grid make Flexbox Obsolete in the Future?

Absolutely not.

In fact, that’s what this article was about. CSS grid and Flexbox, both are designed to solve a different set of problems.

Currently, CSS Grid doesn’t have enough support across the browsers to make production ready websites. The general rule of thumb I use is that a feature must cover more than 95% of global usage. Only then I use that feature in real websites. Currently, Flexbox covers 95% of global usage, and Grid covers 87% of global usage.

Soon Grid will also get good support among the browsers, and we will use a mix of Grids and Flexboxes to make amazing website layouts that previously weren’t possible.

Featured image via DepositPhotos.

Add Realistic Chalk and Sketch Lettering Effects with Sketch’it – only $5!

Source

p img {display:inline-block; margin-right:10px;}
.alignleft {float:left;}
p.showcase {clear:both;}
body#browserfriendly p, body#podcast p, div#emailbody p{margin:0;}