Archive for year: 2020

Original Source: https://www.webdesignerdepot.com/2020/07/popular-design-news-of-the-week-july-13-2020-july-19-2020/

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.

Squircley – All You Need to Start Creating Beautiful Squircles

Tabler Icons – 550+ Highly Customizable Free SVG Icons

Puppertino – A CSS Framework Based on Apple’s Design and Human Guidelines

We are Going to Need Bigger Screens

Coronavirus Changed Everything Including these Logo Designs

This Technique was Supposed to Replace Passwords. Turns Out it’s Surprisingly Easy to Hack

The Web Design Hack Hall of Fame

61 UI/UX Resources for Web Designers

Don’t Quit, Create

BF Tiny Hand: A Free Donald Trump’s Handwriting Font

Dunder Mifflin Identity

16 Examples of Large Typography in Web Design

Style Stage

Spaceboard – Pinterest for Markdown Notes

Flowyak – High-converting Webflow Templates for Bootstrapped Startups

The State of Pixel Perfection

The Best Tools for Checking your Website’s Speed

12 Screen Reader Facts for Accessible Web Design

Why You Should Build your Blog on WordPress Vs. Squarespace

127 Websites to Show Off your Design

Modern Web Development on an 8 Year Old Mac – Music, Design and Stories by Nigel Bunner

Website Best Practices Checklist: 9 Web Design Best Practices

Design Ethnography

Minimum Viable UX: A Guide for SaaS Design

How to Think Smart About your Downtime

Want more? No problem! Keep track of top design news from around the web with Webdesigner News.

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;}

Original Source: http://feedproxy.google.com/~r/1stwebdesigner/~3/UBskkk-TbfM/

…

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/rW52E2pMBCA/wd-my-passport-deals

WD (or Western Digital) My Passport portable storage devices are a must-have for creatives. These unassuming products might look small, but they're mighty when it comes to storing image, video and audio files. In this guide, you'll find a selection of Western Digital's best external hard drives – from the smaller, lower-priced WD My Passport SSD, to the larger WD My Passport 4TB hard drive.

One thing that all of the external hard drives below have in common is that they all have super-fast data transfer speeds and are easy to use. And the best bit? Our clever price comparison tool has found the best deals on each model. Not sure which one is right for you? Jump to the what model should you buy section. And if you can't find what you're looking for here, don't miss our guide to the best external hard drives available right now.

See WD's weekly sales here!
The best WD My Passport deals in 2020

The 4TB iteration of the Western Digital My Passport is a top choice. In fact, we rate it so highly, it takes the top spot in our round up of the best external hard drives (mentioned above). You can also get it in 1TB, 2TB and 5TB iterations, but for value for money, this is our choice. It's got a huge capacity to store all your favourite media – perfect for creatives that deal in massive digital files. 

With the 4TB version, you'll get cloud storage and 256-AES encryption, plus Western Digital's own backup software. Best of all is its great data transfer speeds and, though this hard disc drive (HDD) doesn't offer the speed of a solid state drive (SSD) device (see WD My Passport SSD below), the Western Digital My Passport offers a great balance of quick transfer speeds and massive storage without a huge price tag.

The difference between HDD and SSD

As detailed below on this page, there are some key differences between a solid state drive (SSD) like this one, and a hard disc drive (HHD). In short, the SSD version of WD's My Passport is far faster at transferring data, and it comes in a smaller shell. You'll have to pay a little more to get the storage up to 1TB or 2TBs,  but if you value speed and portability over all else, it'll be worth it. 

Built for both PC and Mac, the My Passport SSD is compatible with a range of ports – both the USB Type-A and Type-C ports, with the latter able to reach speeds of up to 540MB a second. It's also a sturdy model, made to stand a drop of up to two metres. And it's as compact and portable as they come, proving that great things really can come in small packages. 

The WD My Passport Ultra 4TB stands out from the My Passport crowd by offering a three-year warranty – a nice addition if you aim to get a lot of use out of it and want peace of mind – and also having a Mac-specific version of the hard drive available (all the models on this page can be reformatted to work with Macs, but this version is ready out of the box).

Ever so slightly wider than the WD My Passport 4TB, but a little shallower, the Ultra comes with a metal cover and WD Discovery software for WD Backup, WD Security and WD Drive Utilities. It is USB-C ready, and USB 3.0 compatible with an adapter provided, and there are a range of storage sizes, including the huge 5TB option. 

Can't find a portable storage device to suit above? Here are some more great WD My Passport deals available now.

WD My Passport: Which model should you buy?

When choosing the right one for you, foremost on your mind should be its storage capability. Even though many come in massive multi-terabyte iterations, 500GB is plenty to get you started. But if you want to store lots of large video and/or RAW files, or you want to use your external hard drive for housing  games, investing in few more terabytes is a good idea. 

Other important information to consider before making a purchase is the hard drive's connectivity. The rectangular USB-A ports are slowly being replaced by the newer, smaller reversible USB-C ports, found in all newer generation Macs and PCs. 

The difference between HDD and SSD

There are two types of external hard drive: hard disk drives (HDD, also known as mechanical or traditional hard drives) or solid state drives (SSD). An SSD is faster, lighter and less power-hungry, whereas an HDD drive will be cheaper and slower than an SSD. HDDs are also good for storing lots of data as they often have a high capacity. 

So, if you want to store huge amounts of data while keeping prices low, a HDD is the way to go. But if speed is your top priority – for example, if you move a lot of large files, or want to run programs off the drive – then choose an SSD. Or, you can always use a smaller SSD for files that you need to access or move around often, and then store the other data that you use less often on a higher capacity HDD.

Related articles:

The best graphics cardsThe best usb-c monitorsThe best 4K monitors

Original Source: https://www.smashingmagazine.com/2020/07/methods-performance-react-apps/

Methods Of Improving And Optimizing Performance In React Apps

Methods Of Improving And Optimizing Performance In React Apps

Shedrack Akintayo

2020-07-16T11:00:00+00:00
2020-07-16T20:34:27+00:00

React enables web applications to update their user interfaces (UIs) quickly, but that does not mean your medium or large React application will perform efficiently. Its performance will depend on how you use React when building it, and on your understanding of how React operates and the process through which components live through the various phases of their lifecycle. React offers a lot of performance improvements to a web app, and you can achieve these improvements through various techniques, features, and tools.

In this tutorial, we will discuss various methods of optimizing performance in React applications, and also the features of React that we can use to improve performance.

Where To Start Optimizing Performance In A React Application?

We can’t begin to optimize an app without knowing exactly when and where to optimize. You might be asking, “Where do we start?”

During the initial rendering process, React builds a DOM tree of components. So, when data changes in the DOM tree, we want React to re-render only those components that were affected by the change, skipping the other components in the tree that were not affected.

However, React could end up re-rendering all components in the DOM tree, even though not all are affected. This will result in longer loading time, wasted time, and even wasted CPU resources. We need to prevent this from happening. So, this is where we will focus our optimization effort.

In this situation, we could configure every component to only render or diff when necessary, to avoid wasting resources and time.

Measuring Performance

Never start the optimization process of your React application based on what you feel. Instead, use the measurement tools available to analyze the performance of your React app and get a detailed report of what might be slowing it down.

Analyzing React Components With Chrome’s Performance Tab

According to React’s documentation,, while you’re still in development mode, you can use the “Performance” tab in the Chrome browser to visualize how React components mount, update, and unmount.
For example, the image below shows Chrome’s “Performance” tab profiling and analyzing my blog in development mode.

Performance profiler summary (Large preview)

To do this, follow these steps:

Disable all extensions temporarily, especially React Developer Tools, because they can mess with the result of the analysis. You can easily disable extensions by running your browser in incognito mode.
Make sure the application is running in development mode. That is, the application should be running on your localhost.
Open Chrome’s Developer Tools, click on the “Performance” tab, and then click the “Record” button.
Perform the actions you want to profile. Don’t record more than 20 seconds, or else Chrome might hang.
Stop the recording.
React events will be grouped under the “User Timing” label.

The numbers from the profiler are relative. Most times and components will render more quickly in production. Nevertheless, this should help you to figure out when the UI is updated by mistake, as well as how deep and how often the UI updates occur.

React Developer Tools Profiler

According to React’s documentation, in react-dom 16.5+ and react-native 0.57+, enhanced profiling capabilities are available in developer mode using React Developer Tools Profiler. The profiler uses React’s experimental Profiler API to collate timing information about each component that’s rendered, in order to identify performance bottlenecks in a React application.

Just download React Developer Tools for your browser, and then you can use the profiler tool that ships with it. The profiler can only be used either in development mode or in the production-profiling build of React v16.5+. The image below is the profiler summary of my blog in development mode using React Developer Tools Profiler:

React Developer Tools Profiler flamegraph (Large preview)

To achieve this, follow these steps:

Download React Developer Tools.
Make sure your React application is either in development mode or in the production-profiling build of React v16.5+.
Open Chrome’s “Developer Tools” tab. A new tab named “Profiler” will be available, provided by React Developer Tools.
Click the “Record” button, and perform the actions you want to profile. Ideally, stop recording after you have performed the actions you want to profile.
A graph (known as a flamegraph) will appear with all of the event handlers and components of your React app.

Note: See the documentation for more information.

Memoization With React.memo()

React v16 was released with an additional API, a higher-order component called React.memo(). According to the documentation, this exists only as a performance optimization.

Its name, “memo” comes from memoization, which is basically a form of optimization used mainly to speed up code by storing the results of expensive function calls and returning the stored result whenever the same expensive function is called again.

Memoization is a technique for executing a function once, usually a pure function, and then saving the result in memory. If we try to execute that function again, with the same arguments as before, it will just return the previously saved result from the first function’s execution, without executing the function again.

Mapping the description above to the React ecosystem, the functions mentioned are React components and the arguments are props.

The default behavior of a component declared using React.memo() is that it renders only if the props in the component have changed. It does a shallow comparison of the props to check this, but an option is available to override this.

React.memo() boosts the performance of a React app by avoiding re-rendering components whose props haven’t changed or when re-rendering is not needed.

The code below is the basic syntax of React.memo():

const MemoizedComponent = React.memeo((props) => {
// Component code goes in here
})

When To Use React.memo()

Pure functional component
You can use React.memo() if your component is functional, is given the same props, and always renders the same output. You can also use React.memo() on non-pure-functional components with React hooks.
The component renders often
You can use React.memo() to wrap a component that renders often.
The component re-renders with same props
Use React.memo() to wrap a component that is usually provided with the same props during re-rendering.
Medium to high elements
Use it for a component that contains a medium to high number of UI elements to check props for equality.

Note: Be careful when memoizing components that make use of props as callbacks. Be sure to use the same callback function instance between renderings. This is because the parent component could provide different instances of the callback function on every render, which will cause the memoization process to break. To fix this, make sure that the memoized component always receives the same callback instance.

Let’s see how we can use memoization in a real-world situation. The functional component below, called “Photo”, uses React.memo() to prevent re-rendering.

export function Photo({ title, views }) {
return (
<div>
<div>Photo title: {title}</div>
<div>Location: {location}</div>
</div>
);
}
// memoize the component
export const MemoizedPhoto = React.memo(Photo);

The code above consists of a functional component that displays a div containing a photo title and the location of the subject in the photo. We are also memoizing the component by creating a new function and calling it MemoizedPhoto. Memoizing the photo component will prevent the component from re-rendering as long as the props, title, and location are the same on subsequent renderings.

// On first render, React calls MemoizedPhoto function.
<MemoizedPhoto
title=”Effiel Tower”
location=”Paris”
/>

// On next render, React does not call MemoizedPhoto function,
// preventing rendering
<MemoizedPhoto
title=”Effiel Tower”
location=”Paris”
/>

Here, React calls the memoized function only once. It won’t render the component in the next call as long as the props remain the same.

Bundling And Minification

In React single-page applications, we can bundle and minify all our JavaScript code into a single file. This is OK, as long as our application is relatively small.

As our React application grows, bundling and minifying all of our JavaScript code into a single file becomes problematic, difficult to understand, and tedious. It will also affect the performance and loading time of our React app because we are sending a large JavaScript file to the browser. So, we need some process to help us split the code base into various files and deliver them to the browser in intervals as needed.

In a situation like this, we can use some form of asset bundler like Webpack, and then leverage its code-splitting functionality to split our application into multiple files.

Code-splitting is suggested in Webpack’s documentation as a means to improve the loading time of an application. It is also suggested in React’s documentation for lazy-loading (serving only the things currently needed by the user), which can dramatically improve performance.

Webpack suggests three general approaches to code-splitting:

Entry points
Manually split code using entry configuration.
Duplication prevention
Use SplitChunksPlugin to de-duplicate and split chunks.
Dynamic imports
Split code via inline function calls within modules.

Benefits Of Code Splitting

Splitting code assists with the browser’s cache resources and with code that doesn’t change often.
It also helps the browser to download resources in parallel, which reduces the overall loading time of the application.
It enables us to split code into chunks that will be loaded on demand or as needed by the application.
It keeps the initial downloading of resources on first render relatively small, thereby reducing the loading time of the app.

Bundling and minification process (Large preview)

Immutable Data Structures

React’s documentation talks of the power of not mutating data. Any data that cannot be changed is immutable. Immutability is a concept that React programmers should understand.

An immutable value or object cannot be changed. So, when there is an update, a new value is created in memory, leaving the old one untouched.

We can use immutable data structures and React.PureComponent to automatically check for a complex state change. For example, if the state in your application is immutable, you can actually save all state objects in a single store with a state-management library like Redux, enabling you to easily implement undo and redo functionality.

Don’t forget that we cannot change immutable data once it’s created.

Benefits Of Immutable Data Structures

They have no side effects.
Immutable data objects are easy to create, test, and use.
They help us to write logic that can be used to quickly check for updates in state, without having to check the data over and over again.
They help to prevent temporal coupling (a type of coupling in which code depends on the order of execution).

The following libraries help to provide a set of immutable data structures:

immutability-helper
Mutate a copy of data without changing the source.
Immutable.js
Immutable persistent data collections for JavaScript increase efficiency and simplicity.
seamless-immutable
Immutable data structures for JavaScript become backwards-compatible with normal JavaScript arrays and objects.
React-copy-write
This gives immutable state with a mutable API.

Other Methods Of Improving Performance

Use A Production Build Before Deployment

React’s documentation suggests using the minified production build when deploying your app.

React Developer Tools’ “production build” warning (Large preview)

Avoid Anonymous Functions

Because anonymous functions aren’t assigned an identifier (via const/let/var), they aren’t persistent whenever a component inevitably gets rendered again. This causes JavaScript to allocate new memory each time this component is re-rendered, instead of allocating a single piece of memory only once, like when named functions are being used.

import React from ‘react’;

// Don’t do this.
class Dont extends Component {
render() {
return (
<button onClick={() => console.log(‘Do not do this’)}>
Don’t
</button>
);
}
}

// The better way
class Do extends Component {
handleClick = () => {
console.log(‘This is OK’);
}
render() {
return (
<button onClick={this.handleClick}>
Do
</button>
);
}
}

The code above shows two different ways to make a button perform an action on click. The first code block uses an anonymous function in the onClick() prop, and this would affect performance. The second code block uses a named function in the onClick() function, which is the correct way in this scenario.

Mounting And Unmounting Components Often Is Expensive

Using conditionals or tenaries to make a component disappear (i.e. to unmount it) is not advisable, because the component made to disappear will cause the browser to repaint and reflow. This is an expensive process because the positions and geometries of HTML elements in the document will have to be recalculated. Instead, we can use CSS’ opacity and visibility properties to hide the component. This way, the component will still be in the DOM but invisible, without any performance cost.

Virtualize Long Lists

The documentation suggests that if you are rendering a list with a large amount of data, you should render a small portion of the data in the list at a time within the visible viewport. Then, you can render more data as the list is being scrolled; hence, the data is displayed only when it is in the viewport. This process is called “windowing”. In windowing, a small subset of rows are rendered at any given time. There are popular libraries for doing this, two of which are maintained by Brian Vaughn:

react-window
react-virtualized

Conclusion

There are several other methods of improving the performance of your React application. This article has discussed the most important and effective methods of performance optimization.

I hope you’ve enjoyed reading through this tutorial. You can learn more via the resources listed below. If you have any questions, leave them in the comments section below. I’ll be happy to answer every one of them.

References And Related Resources

“Optimizing Performance”, React Docs
“Use React.memo Wisely”, Dmitri Pavlutin
“Performance Optimization Techniques in React”, Niteesh Yadav
“Immutability in React: There’s Nothing Wrong With Mutating Objects”, Esteban Herrera
“10 Ways to Optimize Your React App’s Performance”, Chidume Nnamdi
“5 Tips to Improve the Performance of Your React Apps”, William Le

(ks, ra, al, il)

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

In this tutorial you will learn how to create blog post cards that flip on hover revealing the post excerpt on the back of the card. We will achieve this effect using CSS. The end result is responsive, making the card flip on click, on mobile devices. This GIF shows what you will be able to create by the end of this tutorial.

You need to have basic knowledge of HTML and CSS to begin with. We will explore a few advanced CSS topics such as perspective and transform towards the end. Let’s dive in.

Setting up

Create a blank HTML document and name it index.html. Add the basic HTML skeleton. If you use Visual Studio Code, all you need to do is type “!” and hit enter. You will end up with this.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>

</body>
</html>

I have used the font ‘Lato’ – with font weights 300 and 700. So add the following line below the title tag to embed this font using Google fonts.

<link href="https://fonts.googleapis.com/css2?family=Lato:wght@400;700&display=swap" rel="stylesheet">

Create your stylesheet and name it style.css. Link the stylesheet to your HTML document below the Google fonts CDN link using

<link rel="stylesheet" href="style.css">

I have used these three blog post images from Pexels – post1.jpg, post2.jpg and post3.jpg. You can download the same or choose to include your own. But don’t forget to name them post1.jpg, post2.jpg and post3.jpg.

A single flip card

Once the setup is done, let’s first create a single card that flips – with a front face and a back face. The card flip effect shown in the above GIF happens when the element is rotated 180 degrees along the Y-axis. To create the 3D effect, we need a 3D space for that element by adding perspective to its parent. Look at the difference between 2D effect and 3D effect.

2D Effect

3D Effect

Do you see that the card actually moves out of its space to give you depth effect in 3D? The CSS property perspective helps us do just that. Let’s say we add perspective:20px to the parent. This gives a depth of 20px to that element. This means, a 3D space is created – so the child elements can be moved near or far or can be rotated to give the 3D effect. Let’s create the markup first.

HTML

We need a parent div to add perspective. And then a child element that contains both the front face and back face absolutely positioned. So add this markup in your index.html within the body tag.

<div class="post-wrap"> <!– The parent element –>
<div class="post"> <!– Child element that flips –>
<div class="post-front">
Front face
</div>
<div class="post-back">
Back face
</div>
</div>
</div>

CSS

In style.css, begin with some common styles for all elements:

* {
margin: 0;
padding: 0;
box-sizing: border-box;
}

Add the following styles to html and body:

html, body {
width: 100%;
height: 100%;
}
body{
background-color: #f7fafc;
font-family: ‘Lato’,sans-serif;
font-size: 1rem;
color: #444444;
}

To the post-wrap element, add width, height and perspective.

.post-wrap {
width: 320px;
height: 420px;
perspective: 1000px;
}

Imagine this as a box where perspective is the depth of that box. Next, style the .post div to occupy the full space of its parent.

.post {
position: relative; /* Required to absolutely position the child faces */
width: 100%;
height: 100%;
}

Let’s add styles to the two faces.

.post-front, .post-back {
position: absolute;
width: 100%;
height: 100%;
background-color: white;
}

You will see both of them placed one on top of the other. (You cannot actually see them both. Only the back face is visible. On using the browser inspector tool, you can see that they are positioned on top of each other). But we need the back face to be facing backwards – which means, it needs to be rotated 180 degrees on the Y axis. So add this:

.post-back {
transform: rotateY(180deg);
}

This is what you will see in your browser now.

So the element has turned backwards but the text still appears – as if it’s a glass. We don’t want the back of the element to appear. For that, we use backface-visibility: hidden;. In Safari browser, this works with a -webkit- prefix. Add these now:

.post-front, .post-back {
/* Existing styles here */
-webkit-backface-visibility: hidden;
backface-visibility: hidden;
}

Now you can only see the front face – just the way we want. Next, we need to rotate the post div when the parent is hovered.

.post-wrap:hover .post {
transform: rotateY(180deg);
}

If you check your output now, you will see that the card does rotate but we don’t see any animation or 3D effect. That’s because we haven’t added the most important properties required for these – the transition and transform-style properties.

.post {
/* Existing styles here */
transition: transform 1s;
transform-style: preserve-3d;
}

It’s perfect. We have our flip card ready. It’s time to add our blog post’s content in the markup.

HTML

Add the background image, date and title in the front face.

<div class="post-front">
<div class="post-img" style="background-image: url(‘post1.jpg’);"></div>
<div class="post-info">
<span>June 25, 2020</span>
<h2>Productivity: Expectations vs Reality</h2>
</div>
</div>

The title, excerpt and “Read more” button on the back face.

<div class="post-back">
<div class="post-except">
<h2>Productivity: Expectations vs Reality</h2>
<p>
Et hinc magna voluptatum usu, cum veniam graece et. Ius ea scripserit temporibus, pri cu harum tacimates neglegentur. At adipisci incorrupte nam. Cu qui sumo appareat constituto, possit phaedrum inciderint ex usu, quis ignota cotidieque nam ea. Cum deserunt periculis ocurreret.
</p>
</div>
<a href="#">Read More</a>
</div>

Let’s style this single card.

CSS

Add rounded corners and shadow.

.post-front, .post-back {
/* Existing styles here */
border-radius: 10px;
box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
}

Front face styles.

.post-img {
background-size: cover;
background-position: center;
height: 300px;
border-top-left-radius: 10px;
border-top-right-radius: 10px;
}
.post-info {
padding: 20px 30px 30px;
}
.post-info span {
font-size: 0.8rem;
color: #808080;
}
.post-info h2{
font-weight: bold;
font-size: 1.2rem;
padding-top: 5px;
}

Back face styles.

.post-back {
background-color: #ffffff;
padding: 30px;
display: flex;
flex-direction: column;
justify-content: space-between; /* To push the read more button to bottom */
align-items: flex-start; /* To position the read more button at the left */
}
.post-back h2{
font-weight: bold;
font-size: 1.2rem;
padding-top: 5px;
}
.post-back p {
margin-top: 10px;
line-height: 1.6;
}
.post-back a{
text-decoration: none;
color: #ffffff;
background-color: #5678ba;
padding: 10px 14px;
text-transform: uppercase;
letter-spacing: 0.05em;
font-size: 0.8em;
font-weight: bold;
border-radius: 5px;
}

This does it. We have our single card perfected. Add two more cards in the markup, wrap all the cards within a flex container and add styles to center them. Below is the markup and CSS for the same.

HTML

<div class="container">
<div class="post-wrap"> <!– The parent element –>
<div class="post"> <!– Child element that flips –>
<div class="post-front">
<div class="post-img" style="background-image: url(‘post1.jpg’);"></div>
<div class="post-info">
<span>June 25, 2020</span>
<h2>Productivity: Expectations vs Reality</h2>
</div>
</div>
<div class="post-back">
<div class="post-except">
<h2>Productivity: Expectations vs Reality</h2>
<p>
Et hinc magna voluptatum usu, cum veniam graece et. Ius ea scripserit temporibus, pri cu harum tacimates neglegentur. At adipisci incorrupte nam. Cu qui sumo appareat constituto, possit phaedrum inciderint ex usu, quis ignota cotidieque nam ea. Cum deserunt periculis ocurreret.
</p>
</div>
<a href="#">Read More</a>
</div>
</div>
</div>
<div class="post-wrap">
<div class="post">
<div class="post-front">
<div class="post-img" style="background-image: url(‘post2.jpg’);"></div>
<div class="post-info">
<span>May 19, 2020</span>
<h2>Will Artificial Intelligence Rule the World?</h2>
</div>
</div>
<div class="post-back">
<div class="post-excerpt">
<h2>Will Artificial Intelligence Rule the World?</h2>
<p>
Habemus principes eos id, eu sonet patrioque nam. Eu his mazim insolens, et vim saperet laboramus. Enim gubergren temporibus vix ei. Dicunt iuvaret sadipscing te nam, legere assueverit sed in, at everti labores.
</p>
<p>
Dico facilis dissentias mea cu. Nam assum eripuit an.
</p>
</div>
<a href="#">Read More</a>
</div>
</div>
</div>
<div class="post-wrap">
<div class="post">
<div class="post-front">
<div class="post-img" style="background-image: url(‘post3.jpg’);"></div>
<div class="post-info">
<span>July 11, 2020</span>
<h2>This Week’s Top Stories in Web Design</h2>
</div>
</div>
<div class="post-back">
<div class="post-except">
<h2>This Week’s Top Stories in Web Design</h2>
<p>
Scaevola definitiones eum et. Assum postulant periculis per ei. Doming scribentur sea an. Eum verear docendi tincidunt in.
</p>
<p>
Ne duo posse deserunt, at eam euismod torquatos, est velit essent in. Et diam meliore cotidieque vim. Dicit ignota repudiandae ei pri.
</p>
</div>
<a href="#">Read More</a>
</div>
</div>
</div>
</div>

CSS

.container {
max-width: 1200px;
margin: auto;
padding: 60px;
display: flex;
justify-content: center;
flex-wrap: wrap; /* Required to position the posts one below the other on smaller devices */
}
.post-wrap {
/* Existing styles here */
flex: 1;
margin: 0 15px 30px;
}

Now the only pending part is to make this responsive. Just change the fixed width of .post-wrap to min-width and max-width instead.

.post-wrap {
/* Existing styles here */
min-width: 300px;
max-width: 380px;
}

And we did it! Resize your browser to see how the posts position themselves on different screen sizes.

In this tutorial, we used the flip card effect for blog posts. You can get creative and use this to display team profiles, portfolio items or anything really. Just in case you didn’t get the expected output, here is the complete source code for you.

DOWNLOAD SOURCE CODE