25 Free Figma Resources, Tutorials, Templates, UI Kits and More!

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

If you work in the design industry, Figma is an excellent resource. Not only does it allow you to work on design projects with your team remotely, it also allows you to collaborate in real-time. It’s a true-blue interfacing tool that includes a variety of features to make it easy to generate new ideas and follow them through to completion.

Figma also makes it possible to create animated prototypes, solicit contextual feedback from your team or clients, build systems to use again and again, and more. It’s a pretty versatile tool that makes collaborating on design projects across the office or across the country a snap.

But as with getting started with any new tool, setting up everything and getting into a good workflow might take some trial and error. That’s why we’ve put together some useful Figma resources for establishing your team’s workflow, including tutorials, templates, UI kits, and more.

Your Web Designer Toolbox
Unlimited Downloads: 500,000+ Web Templates, Icon Sets, Themes & Design Assets



Here are some tutorials that walk you through getting started with Figma as well as some of its more complex features.

1. Figma’s YouTube Channel

Example from Figma’s YouTube Channel

2. Figma Tutorial for Creating a Mobile Layout

Example from Figma Tutorial for Creating a Mobile Layout

3. DesignLab: Figma 101 – A Free 7-day Course for Mastering Figma

Example from DesignLab: Figma 101 - A Free 7-day Course for Mastering Figma

4. Envato Tuts+ Figma Tips and Tricks

Example from Envato Tuts+ Figma Tips and Tricks


5. Figma YouTube Channel: Getting Started

Example from Figma YouTube Channel: Getting Started

6. 12 Free Figma Tutorials & Courses

Example from 12 Free Figma Tutorials & Courses

7. Figma Tutorial: How (and Why) to Use it for Your Next Project

Example from Figma Tutorial: How (and Why) to Use it for Your Next Project

8. LevelUpTuts: Mastering Figma Videos

Example from LevelUpTuts: Mastering Figma Videos

9. Creative Bloq: Create a Responsive Dashboard with Figma

Example from Creative Bloq: Create a Responsive Dashboard with Figma

10. Understanding Figma as a UI Beginner

Example from Understanding Figma as a UI Beginner

11. How to Streamline Your UI/UX Workflow with Figma

Example from How to Streamline Your UI/UX Workflow with Figma


If you want to get up and running right away in Figma, the following templates should make the task easy.

12. Figma Templates

Example from Figma Templates

13. Figma Freebies

Example from Figma Freebies

14. FigmaCrush Templates

Example from FigmaCrush Templates

UI Kits

These UI kits for Figma take away some of the guesswork in establishing the overall look and feel of your projects and workflow.

15. Free Figma UI Kits

Example from Free Figma UI Kits

16. Figma Freebies UI Kits

Example from Figma Freebies UI Kits

17. Figma UI Kit

Example from Figma UI Kit

18. Free UI-Kit for Sketch & Figma

Example from Free UI-Kit for Sketch & Figma

Other Resources

For some more general information, tutorials, and comprehensive guides, these miscellaneous resources are also helpful.

19. Figma Finder – Figma Resources & UI Kits

Example from Figma Finder

20. Free Figma UI Kits, Templates, & Design Systems

Example from Free Figma UI Kits, Templates, & Design Systems

21. FigmaCrush – Figma UI Kits, Templates & Freebies

Example from FigmaCrush - Figma UI Kits, Templates & Freebies

22. Figma Freebies – Free UI Kits & Figma Templates

Example from Figma Freebies - Free UI Kits & Figma Templates

23. Figma Freebies – Systems, Grids, UI Kits & Templates

Example from Figma Freebies - Systems, Grids, UI Kits & Templates

24. Figma Resources

Example from Figma Resources

25. Free Figma Resources & Templates

Example from Free Figma Resources & Templates

Getting Started with Figma Has Never Been So Easy

There’s no reason you have to go it alone when learning about how Figma works. This collection of tutorials, UI Kits, and other resources should make it a lot easier to get started and to learn how to best use Figma for your team.

All of the resources included here are listed as free, but make sure to read the terms for each before you use them in a project for personal or commercial use.

Case Study: Portfolio of Bruno Arizio

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


Bruno Arizio, Designer — @brunoarizio

Since I first became aware of the energy in this community, I felt the urge to be more engaged in this ‘digital avant-garde landscape’ that is being cultivated by the amazing people behind Codrops, Awwwards, CSSDA, The FWA, Webby Awards, etc. That energy has propelled me to set up this new portfolio, which acted as a way of putting my feet into the water and getting used to the temperature.

I see this community being responsible for pushing the limits of what is possible on the web, fostering the right discussions and empowering the role of creative developers and creative designers across the world.

With this in mind, it’s difficult not to think of the great art movements of the past and their role in mediating change. You can easily draw a parallel between this digital community and the Impressionists artists in the last century, or as well the Bauhaus movement leading our society into modernism a few decades ago. What these periods have in common is that they’re pushing the boundaries of what is possible, of what is the new standard, doing so through relentless experimentation. The result of that is the world we live in, the products we interact with, and the buildings we inhabit.

The websites that are awarded today, are so because they are innovating in some aspects, and those innovations eventually become a new standard. We can see that in the apps used by millions of people, in consumer websites, and so on. That is the impact that we make.

I’m not saying that a new interaction featured on a new portfolio launched last week is going to be in the hands of millions of people across the globe in the following week, although constantly pushing these interactions to its limits will scale it and eventually make these things adopted as new standards. This is the kind of responsibility that is in our hands.

Open Source

We decided to be transparent and take a step forward in making this entire project open source so people can learn how to make the things we created. We are both interested in supporting the community, so feel free to ask us questions on Twitter or Instagram (@brunoarizio and @lhbzr), we welcome you to do so!

The repository is available on GitHub.

Design Process

With the portfolio, we took a meticulous approach to motion and collaborated to devise deliberate interactions that have a ‘realness’ to it, especially on the main page.

The mix of the bending animation with the distortion effect was central to making the website ‘tactile’. It is meant to feel good when you shuffle through the projects, and since it was published we received a lot of messages from people saying how addictive the navigation is.

A lot of my new ideas come from experimenting with shaders and filters in After Effects, and just after I find what I’m looking for — the ‘soul’ of the project — I start to add the ‘grid layer’ and begin to structure the typography and other elements.

In this project, before jumping to Sketch, I started working with a variety of motion concepts in AE, and that’s when the version with the convection bending came in and we decided to take it forward. So we can pretty much say that the project was born from motion, not from a layout in this matter. After the main idea was solid enough, I took it to Sketch, designed a simple grid and applied the typography.


Working in collaboration with Luis was so productive. This is the second (of many to come) projects working together and I can safely say that we had a strong connection from start to finish, and that was absolutely important for the final results. It wasn’t a case in which the designer creates the layouts and hands them over to a developer and period. This was a nuanced relationship of constant feedback. We collaborated daily from idea to production, and it was fantastic how dev and design had this keen eye for perfectionism.

From layout to code we were constantly fine-tuning every aspect: from the cursor kinetics to making overhaul layout changes and finding the right tone for the easing curves and the noise mapping on the main page.

When you design a portfolio, especially your own, it feels daunting since you are free to do whatever you want. But the consequence is that this will dictate how people will see your work, and what work you will be doing shortly after. So making the right decisions deliberately and predicting its impact is mandatory for success.

Technical Breakdown

Luis Henrique Bizarro, Creative Developer — @lhbzr

Motion Reference

This was the video of the motion reference that Bruno shared with me when he introduced me his ideas for his portfolio. I think one of the most important things when starting a project like this with the idea of implementing a lot of different animations, is to create a little prototype in After Effects to drive the developer to achieve similar results using code.

The Tech Stack

The portfolio was developed using:


That’s my favorite stack to work with right now; it gives me a lot of freedom to focus on animations and interactions instead of having to follow guidelines of a specific framework.

In this particular project, most of the code was written from scratch using ECMAScript 2015+ features like Classes, Modules, and Promises to handle the route transitions and other things in the application.

In this case study, we’ll be focusing on the WebGL implementation, since it’s the core animation of the website and the most interesting thing to talk about.

1. How to measure things in Three.js

This specific subject was already covered in other articles of Codrops, but in case you’ve never heard of it before, when you’re working with Three.js, you’ll need to make some calculations in order to have values that represent the correct sizes of the viewport of your browser.

In my last projects, I’ve been using this Gist by Florian Morel, which is basically a calculation that uses your camera field-of-view to return the values for the height and width of the Three.js environment.

// createCamera()
const fov = THREEMath.degToRad(this.camera.fov);
const height = 2 * Math.tan(fov / 2) * this.camera.position.z;
const width = height * this.camera.aspect;

this.environment = {

// createPlane()
const { height, width } = this.environment;

this.plane = new PlaneBufferGeometry(width * 0.75, height * 0.75, 100, 50);

I usually store these two variables in the wrapper class of my applications, this way we just need to pass it to the constructor of other elements that will use it.

In the embed below, you have a very simple implementation of a PlaneBufferGeometry that covers 75% of the height and width of your viewport using this solution.

2. Uploading textures to the GPU and using them in Three.js

In order to avoid the textures to be processed in runtime while the user is navigating through the website, I consider a very good practice to upload all images to the GPU immediately when they’re ready. On Bruno’s portfolio, this process happens during the preloading of the website. (Kudos to Fabio Azevedo for introducing me this concept a long time ago in previous projects.)

Another two good additions, in case you don’t want Three.js to resize and process the images you’re going to use as textures, are disabling mipmaps and change how the texture is sampled by changing the generateMipmaps and minFilter attributes.

this.loader = new TextureLoader();

this.loader.load(image, texture => {
texture.generateMipmaps = false;
texture.minFilter = LinearFilter;
texture.needsUpdate = true;

this.renderer.initTexture(texture, 0);

The method .initTexture() was introduced back in the newest versions of Three.js in the WebGLRenderer class, so make sure to update to the latest version of the library to be able to use this feature.

But my texture is looking stretched! The default behavior of Three.js map attribute from MeshBasicMaterial is to make your image fit into the PlaneBufferGeometry. This happens because of the way the library handles 3D models. But in order to keep the original aspect ratio of your image, you’ll need to do some calculations as well.

There’s a lot of different solutions out there that don’t use GLSL shaders, but in our case we’ll also need them to implement our animations. So let’s implement the aspect ratio calculations in our fragment shader that will be created for the ShaderMaterial class.

So, all you need to do is pass your Texture to your ShaderMaterial via the uniforms attribute. In the fragment shader, you’ll be able to use all variables passed via the uniforms attribute.

In Three.js Uniform documentation you have a good reference of what happens internally when you pass the values. For example, if you pass a Vector2, you’ll be able to use a vec2 inside your shaders.

We need two vec2 variables to do the aspect ratio calculations: the image resolution and the resolution of the renderer. After passing them to the fragment shader, we just need to implement our calculations.

this.material = new ShaderMaterial({
uniforms: {
image: {
value: texture
imageResolution: {
value: new Vector2(texture.image.width, texture.image.height)
resolution: {
type: “v2”,
value: new Vector2(window.innerWidth, window.innerHeight)
fragmentShader: `
uniform sampler2D image;
uniform vec2 imageResolution;
uniform vec2 resolution;

varying vec2 vUv;

void main() {
vec2 ratio = vec2(
min((resolution.x / resolution.y) / (imageResolution.x / imageResolution.y), 1.0),
min((resolution.y / resolution.x) / (imageResolution.y / imageResolution.x), 1.0)

vec2 uv = vec2(
vUv.x * ratio.x + (1.0 – ratio.x) * 0.5,
vUv.y * ratio.y + (1.0 – ratio.y) * 0.5

gl_FragColor = vec4(texture2D(image, uv).xyz, 1.0);
vertexShader: `
varying vec2 vUv;

void main() {
vUv = uv;

vec3 newPosition = position;

gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);

In this snippet we’re using template strings to represent the code of our shaders only to keep it simple when using CodeSandbox, but I highly recommend using glslify to split your shaders into multiple files to keep your code more organized in a more robust development environment.

We’re all good now with the images! Our images are preserving their original aspect ratio and we also have control over how much space they’ll use in our viewport.

3. How to implement infinite scrolling

Infinite scrolling can be something very challenging, but in a Three.js environment the implementation is smoother than it’d be without WebGL by using CSS transforms and HTML elements, because you don’t need to worry about storing the original position of the elements and calculate their distance to avoid browser repaints.

Overall, a simple logic for the infinite scrolling should follow these two basic rules:

If you’re scrolling down, your elements move up — when your first element isn’t on the screen anymore, you should move it to the end of the list. If you’re scrolling up, your elements move to down — when your last element isn’t on the screen anymore, you should move it to the start of the list.

Sounds reasonable right? So, first we need to detect in which direction the user is scrolling.

this.position.current += (this.scroll.values.target – this.position.current) * 0.1;

if (this.position.current < this.position.previous) {
this.direction = “up”;
} else if (this.position.current > this.position.previous) {
this.direction = “down”;
} else {
this.direction = “none”;

this.position.previous = this.position.current;

The variable this.scroll.values.target is responsible for defining to which scroll position the user wants to go. Then the variable this.position.current represents the current position of your scroll, it goes smoothly to the value of the target with the * 0.1 multiplication.

After detecting the direction the user is scrolling towards, we just store the current position to the this.position.previous variable, this way we’ll also have the right direction value inside the requestAnimationFrame.

Now we need to implement the checking method to make our items have the expected behavior based on the direction of the scroll and their position. In order to do so, you need to implement a method like this one below:

check() {
const { height } = this.environment;
const heightTotal = height * this.covers.length;

if (this.position.current < this.position.previous) {
this.direction = “up”;
} else if (this.position.current > this.position.previous) {
this.direction = “down”;
} else {
this.direction = “none”;

this.projects.forEach(child =>; {
child.isAbove = child.position.y > height;
child.isBelow = child.position.y < -height;

if (this.direction === “down” && child.isAbove) {
const position = child.location – heightTotal;

child.isAbove = false;
child.isBelow = true;

child.location = position;

if (this.direction === “up” && child.isBelow) {
const position = child.location + heightTotal;

child.isAbove = true;
child.isBelow = false;

child.location = position;


Now our logic for the infinite scroll is finally finished! Drag and drop the embed below to see it working.

You can also view the fullscreen demo here.

4. Integrate animations with infinite scrolling

The website motion reference has four different animations happening while the user is scrolling:

Movement on the z-axis: the image moves from the back to the front. Bending on the z-axis: the image bends a little bit depending on its position. Image scaling: the image scales slightly when moving out of the screen.Image distortion: the image is distorted when we start scrolling.

My approach to implementing the animations was to use a calculation of the element position divided by the viewport height, giving me a percentage number between -1 and 1. This way I’ll be able to map this percentage into other values inside the ShaderMaterial instance.

-1 represents the bottom of the viewport. 0 represents the middle of the viewport. 1 represents the top of the viewport.

const percent = this.position.y / this.environment.height;
const percentAbsolute = Math.abs(percent);

The implementation of the z-axis animation is pretty simple, because it can be done directly with JavaScript using this.position.z from Mesh, so the code for this animation looks like this:

this.position.z = map(percentAbsolute, 0, 1, 0, -50);

The implementation of the bending animation is slightly more complex, we need to use the vertex shaders to bend our PlaneBufferGeometry. I’ve choose distortion as the value to control this animation inside the shaders. Then we also pass two other parameters distortionX and distortionY which controls the amount of distortion of the x and y axis.

this.material.uniforms.distortion.value = map(percentAbsolute, 0, 1, 0, 5);

uniform float distortion;
uniform float distortionX;
uniform float distortionY;

varying vec2 vUv;

void main() {
vUv = uv;

vec3 newPosition = position;

// 50 is the number of x-axis vertices we have in our PlaneBufferGeometry.
float distanceX = length(position.x) / 50.0;
float distanceY = length(position.y) / 50.0;

float distanceXPow = pow(distortionX, distanceX);
float distanceYPow = pow(distortionY, distanceY);

newPosition.z -= distortion * max(distanceXPow + distanceYPow, 2.2);

gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);

The implementation of image scaling was made with a single function inside the fragment shader:

this.material.uniforms.scale.value = map(percent, 0, 1, 0, 0.5);

vec2 zoom(vec2 uv, float amount) {
return 0.5 + ((uv – 0.5) * (1.0 – amount));

void main() {
// …

uv = zoom(uv, scale);

// …

The implementation of distortion was made with glsl-noise and a simple calculation displacing the texture on the x and y axis based on user gestures:

onTouchStart() {
TweenMax.to(this.material.uniforms.displacementY, 0.4, {
value: 0.1

onTouchEnd() {

TweenMax.to(this.material.uniforms.displacementY, 0.4, {
value: 0

#pragma glslify: cnoise = require(glsl-noise/classic/3d)

void main() {
// …

float noise = cnoise(vec3(uv, cos(time * 0.1)) * 10.0 + time * 0.5);

uv.x += noise * displacementX;
uv.y += noise * displacementY;

// …

And that’s our final code of the fragment shader merging all the three animations together.

#pragma glslify: cnoise = require(glsl-noise/classic/3d)

uniform float alpha;
uniform float displacementX;
uniform float displacementY;
uniform sampler2D image;
uniform vec2 imageResolution;
uniform vec2 resolution;
uniform float scale;
uniform float time;

varying vec2 vUv;

vec2 zoom(vec2 uv, float amount) {
return 0.5 + ((uv – 0.5) * (1.0 – amount));

void main() {
vec2 ratio = vec2(
min((resolution.x / resolution.y) / (imageResolution.x / imageResolution.y), 1.0),
min((resolution.y / resolution.x) / (imageResolution.y / imageResolution.x), 1.0)

vec2 uv = vec2(
vUv.x * ratio.x + (1.0 – ratio.x) * 0.5,
vUv.y * ratio.y + (1.0 – ratio.y) * 0.5

float noise = cnoise(vec3(uv, cos(time * 0.1)) * 10.0 + time * 0.5);

uv.x += noise * displacementX;
uv.y += noise * displacementY;

uv = zoom(uv, scale);

gl_FragColor = vec4(texture2D(image, uv).xyz, alpha);

You can also view the fullscreen demo here.

Photos used in examples of the article were taken by Willian Justen and Azamat Zhanisov.


We hope you liked the Case Study we’ve written together, if you have any questions, feel free to ask us on Twitter or Instagram (@brunoarizio and @lhbzr), we would be very happy to receive your feedback.

Case Study: Portfolio of Bruno Arizio was written by Bruno Arizio and published on Codrops.

Understanding and Using rem Units in CSS

Original Source: https://www.sitepoint.com/understanding-and-using-rem-units-in-css/?utm_source=rss

CSS units have been the subject of several articles here on SitePoint (such as A Look at Length Units in CSS, The New CSS3 Relative Font Sizing Units, and The Power of em Units in CSS). In this article, we increase the count by having an in-depth look at rem units, which have excellent browser support and a polyfill if you need support for old IE.

This article was updated in December, 2019 to reflect the current state of rem unit sizing with CSS. For more on CSS font and text properties, read our book, CSS Master, 2nd Edition.

What Are rem Units?

You might have encountered the term “R.E.M.” before while listening to the radio or your music player. Unlike their musical counterparts, named for the “Rapid Eye Movement” during deep sleep, in CSS rem stands for “root em”. They won’t make you lose your religion nor believe in a man on the moon. What they can do is help you achieve a harmonious and balanced design.

According to the W3C spec the definition for one rem unit is:

Equal to the computed value of font-size on the root element. When specified on the font-size property of the root element, the rem units refer to the property’s initial value.

This means that 1rem equals the font size of the html element (which for most browsers has a default value of 16px).

Rem Units vs. Em Units

The main problem with em units is that they are relative to the font size of their own element. As such they can cascade and cause unexpected results. Let’s consider the following example, where we want lists to have a font size of 12px, in the case where the root font size is the default 16px:

[code language=”css”]
html {
font-size: 100%;

ul {
font-size: 0.75em;

If we have a list nested inside another list, the font size of the inner list will be 75% of the size of its parent (in this case 9px). We can still overcome this problem by using something along these lines:

[code language=”css”]
ul ul {
font-size: 1em;

This does the trick, however we still have to pay a lot of attention to situations where nesting gets even deeper.

With rem units, things are a simpler:

[code language=”css”]
html {
font-size: 100%;

ul {
font-size: 0.75rem;

As all the sizes are referenced from the root font size, there is no more need to cover the nesting cases in separate declarations.

Font Sizing with Rem Units

One of the pioneers of using rem units for font sizing is Jonathan Snook with his Font sizing with REM article, back in May, 2011. Like many other CSS developers, he had to face the problems that em units bring in complex layouts.

At that time, older versions of IE still had large market shares and they were unable to zoom text that was sized with pixels. However, as we saw earlier, it is very easy to lose track of nesting and get unexpected results with em units.

The main issue with using rem for font sizing is that the values are somewhat difficult to use. Let’s see an example of some common font sizes expressed in rem units, assuming, of course, that the base size is 16px:

10px = 0.625rem
12px = 0.75rem
14px = 0.875rem
16px = 1rem (base)
18px = 1.125rem
20px = 1.25rem
24px = 1.5rem
30px = 1.875rem
32px = 2rem

As we can see, these values are not very convenient for making calculations. For this reason, Snook used a trick called “62.5%“. It was not a new discovery, by any means, as it was already used with em units:

[code language=”css”]
body { font-size:62.5%; } /* =10px */
h1 { font-size: 2.4em; } /* =24px */
p { font-size: 1.4em; } /* =14px */
li { font-size: 1.4em; } /* =14px? */

As rem units are relative to the root element, Snook’s variant of the solution becomes:

[code language=”css”]
html { font-size: 62.5%; } /* =10px */
body { font-size: 1.4rem; } /* =14px */
h1 { font-size: 2.4rem; } /* =24px */

One also had to take into account the other browsers that didn’t support rem. Thus the code from above would have actually been written this way:

[code language=”css”]
html {
font-size: 62.5%;

body {
font-size: 14px;
font-size: 1.4rem;

h1 {
font-size: 24px;
font-size: 2.4rem;

While this solution seems to be close to the status of a “golden rule”, there are people who advise against using it blindingly. Harry Roberts writes his own take on the use of rem units. In his opinion, while the 62.5% solution makes calculation easier (as the font sizes in px are 10 times their rem values), it ends up forcing developers to explicitly rewrite all the font sizes in their website.

The post Understanding and Using rem Units in CSS appeared first on SitePoint.

5 Signs It’s Time to Quit Your Job

Original Source: https://www.sitepoint.com/quitting-job-signs/?utm_source=rss

“Jerry wouldn’t let me go to the emergency room.”

Jenny010137 recounted her story on Reddit. She had a major health crisis, but Jerry, her boss, wasn’t buying it.

Jerry wouldn’t let me go to the emergency room after the heavy vaginal bleeding I had been experiencing suddenly got way worse. I went over his head and got permission to go. I called my mom, told her to meet me in the ER. The ER nurse said he’d never seen so much blood. An ER nurse said this. It’s determined I need a couple of blood transfusions and will be admitted.

Jenny’s mom calls Jerry on her behalf.

My mom calls Jerry, who then proceeds to tell her that it’s just stress, and I NEED TO GET BACK TO WORK. At this point, I couldn’t even lift my own head up, but sure, I can take a bus across town and go back to work.

Doctors told Jenny they found a large growth that needed a biopsy.

They found a large growth that needed a biopsy. Jerry kept insisting that it couldn’t be cancer because I’d be tired and losing weight. I had lost eight pounds in a week and went to bed the minute I got home. I was still recovering from the procedure when Jerry called me to let me know I was fired for taking too much time off. Five days later, I was diagnosed with cancer. Fuck you, Jerry. Fuck you.

Think about that for a second.

Jenny is losing blood rapidly. There’s a good chance she’s dying. Her boss can’t be bothered to verify that she’s okay. While she’s in the hospital fighting for her life, he fires her for taking “too much time off.”

This situation is obviously one to walk away from.

But it’s not always so clear cut.

Sometimes you’re in a situation where there are both positive and negative aspects of the job. With situations like these, the decision isn’t always as obvious as we’d like it to be. Walk away from a promising position prematurely and you may burn bridges and destroy any goodwill you’ve built up.

What’s the best way to know?

If you focus on the signs, you may be right, but too much uncertainty means you may handle things in a way that’s less than ideal.

There’s a better way.

Focus your attention on the right set of principles and you’ll have the framework you need to decide when it’s time to quit your job (or not). Let’s take a look at these principles.

Principle #1: Your Job Violates Your Boundaries

Art Markman, professor of psychology at the University of Texas at Austin, shared a story relayed to him by a reader.

My mother suddenly passed away on a Friday evening. On the Sunday my boss showed up to my house with groceries and flowers and suggested that I go into the office on Monday for the quarterly meeting. After all, “this was a pivotal time” for the business.

I didn’t go in the next day because of my overwhelming grief. I later found out that I was to receive an award on that Monday. Was this a career-limiting move, or is my boss not clear on boundaries?

This boss meant well, but his concern was self-serving and not at all in the best interests of his employee. What’s worse, he may not have understood why it was a problem if his employee spoke to him about it later on.

This is why you need boundaries.

Boundaries act as gatekeepers in a variety of professional, emotional, social, physical and situations. Here’s why you need boundaries and why they’re so important:

They protect you from abusive or toxic behavior (for example, managers or co-workers making inappropriate demands, verbal abuse, inappropriate conversation, or details that are immoral or infringe on your values).
Boundaries define how others can or should communicate with you.
Good boundaries protect you from sacrificing your autonomy, freedom of choice, family, identity, integrity or contacts.
Great boundaries attract more of the people, projects and opportunities you want. When set up appropriately, these boundaries repel the items you don’t want.

How do you set great boundaries?

It’s a simple process. First, determine what you do and don’t want. Next, figure out what your employer wants or doesn’t want.

Sounds simple, right?

Figuring out what you want is really about asking the right question (see above). Figuring out what your employer wants is really about identifying criteria that are documented in some way. That’s important, because it gives you the leverage you need to protect yourself (legally) against any inappropriate behavior.

But setting boundaries is risky.

Consider this common idea: Tell your boss No and you could get fired (or worse). If developers are smart, they’ll avoid biting the hand that feeds them.

This rationale is trash.

If you set a boundary, it will be tested. Those around you — your manager, co-workers, other developers — will attempt to back you into a corner. You’re going to have to find appropriate ways to rise to the challenge and enforce your boundaries.

Why go to the trouble? Because boundaries limit the damage from the other four principles discussed in this article. If you don’t have strong boundaries, you’ll face the problems discussed here. It doesn’t matter if you’re employed or you own your own business.

If you have poor boundaries, you won’t be able to achieve your goals.

Principle #2: Your Job Goes Against Your Goals

Reddit user YellowRoses had goals until their boss torpedoed those goals.

How do you deal with feeling disrespected by your boss? from r/careerguidance

They were promised a promotion. They negotiated with their boss and earned a verbal agreement regarding their promotion, only for said promotion to be denied with an “Oh, that’s not happening now.” No explanation or attempts at justifying the rescinded promise.

What if your employer isn’t aware of your goals? Still doesn’t matter. If you have a specific goal in mind, you’re responsible for that goal. Not your co-workers, employer, or family members. Are you pushing for the director’s position that’s opened up? Prefer to stay in your current role but receive the same pay as managers? It’s on you.

This seems obvious, until you realize most people wait to be chosen. They wait for someone to approve of their audition, accept them, recruit them, promote them, extend a helping hand, etc. Which goes nowhere fast.

To be clear, it’s generally a good idea to discuss your goals with your employer, provided that you’re in a good place to do so. If your employer laughs at you, mocks your goal, or decides they’re unwilling to help you meet said goals, it’s on you to make it happen.

The post 5 Signs It’s Time to Quit Your Job appeared first on SitePoint.

Scroll, Refraction and Shader Effects in Three.js and React

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

In this tutorial I will show you how to take a couple of established techniques (like tying things to the scroll-offset), and cast them into re-usable components. Composition will be our primary focus.

In this tutorial we will:

build a declarative scroll rigmix HTML and canvashandle async assets and loading screens via React.Suspenseadd shader effects and tie them to scrolland as a bonus: add an instanced variant of Jesper Vos multiside refraction shader

Setting up

We are using React, hooks, Three.js and react-three-fiber. The latter is a renderer for Three.js which allows us to declare the scene graph by breaking up tasks into self-contained components. However, you still need to know a bit of Three.js. All there is to know about react-three-fiber you can find on the GitHub repo’s readme. Check out the tutorial on alligator.io, which goes into the why and how.

We don’t emulate a scroll bar, which would take away browser semantics. A real scroll-area in front of the canvas with a set height and a listener is all we need.

I decided to divide the content into:

virtual content sectionsand pages, each 100vh long, this defines how long the scroll area is

function App() {
const scrollArea = useRef()
const onScroll = e => (state.top.current = e.target.scrollTop)
useEffect(() => void onScroll({ target: scrollArea.current }), [])
return (
<Canvas orthographic>{/* Contents … */}</Canvas>
<div ref={scrollArea} onScroll={onScroll}>
<div style={{ height: `${state.pages * 100}vh` }} />

scrollTop is written into a reference because it will be picked up by the render-loop, which is carrying out the animations. Re-rendering for often occurring state doesn’t make sense.

A first-run effect synchronizes the local scrollTop with the actual one, which may not be zero.

Building a declarative scroll rig

There are many ways to go about it, but generally it would be nice if we could distribute content across the number of sections in a declarative way while the number of pages defines how long we have to scroll. Each content-block should have:

an offset, which is the section index, given 3 sections, 0 means start, 2 means end, 1 means in betweena factor, which gets added to the offset position and subtracted using scrollTop, it will control the blocks speed and direction

Blocks should also be nestable, so that sub-blocks know their parents’ offset and can scroll along.

const offsetContext = createContext(0)

function Block({ children, offset, factor, …props }) {
const ref = useRef()
// Fetch parent offset and the height of a single section
const { offset: parentOffset, sectionHeight } = useBlock()
offset = offset !== undefined ? offset : parentOffset
// Runs every frame and lerps the inner block into its place
useFrame(() => {
const curY = ref.current.position.y
const curTop = state.top.current
ref.current.position.y = lerp(curY, (curTop / state.zoom) * factor, 0.1)
return (
<offsetContext.Provider value={offset}>
<group {…props} position={[0, -sectionHeight * offset * factor, 0]}>
<group ref={ref}>{children}</group>

This is a block-component. Above all, it wraps the offset that it is given into a context provider so that nested blocks and components can read it out. Without an offset it falls back to the parent offset.

It defines two groups. The first is for the target position, which is the height of one section multiplied by the offset and the factor. The second, inner group is animated and cancels out the factor. When the user scrolls to the given section offset, the block will be centered.

We use that along with a custom hook which allows any component to access block-specific data. This is how any component gets to react to scroll.

function useBlock() {
const { viewport } = useThree()
const offset = useContext(offsetContext)
const canvasWidth = viewport.width / zoom
const canvasHeight = viewport.height / zoom
const sectionHeight = canvasHeight * ((pages – 1) / (sections – 1))
// …
return { offset, canvasWidth, canvasHeight, sectionHeight }

We can now compose and nest blocks conveniently:

<Block offset={2} factor={1.5}>
<Block factor={-0.5}>
<SubContent />

Anything can read from block-data and react to it (like that spinning cross):

function Cross() {
const ref = useRef()
const { viewportHeight } = useBlock()
useFrame(() => {
const curTop = state.top.current
const nextY = (curTop / ((state.pages – 1) * viewportHeight)) * Math.PI
ref.current.rotation.z = lerp(ref.current.rotation.z, nextY, 0.1)
return (
<group ref={ref}>

Mixing HTML and canvas, and dealing with assets

Keeping HTML in sync with the 3D world

We want to keep layout and text-related things in the DOM. However, keeping it in sync is a bit of a bummer in Three.js, messing with createElement and camera calculations is no fun.

In three-fiber all you need is the <Dom /> helper (@beta atm). Throw this into the canvas and add declarative HTML. This is all it takes for it to move along with its parents’ world-matrix.

<group position={[10, 0, 0]}>


If we strictly divide between layout and visuals, supporting a11y is possible. Dom elements can be behind the canvas (via the prepend prop), or in front of it. Make sure to place them in front if you need them to be accessible.

Responsiveness, media-queries, etc.

While the DOM fragments can rely on CSS, their positioning overall relies on the scene graph. Canvas elements on the other hand know nothing of the sort, so making it all work on smaller screens can be a bit of a challenge.

Fortunately, three-fiber has auto-resize inbuilt. Any component requesting size data will be automatically informed of changes.

You get:

viewport, the size of the canvas in its own units, must be divided by camera.zoom for orthographic camerassize, the size of the screen in pixels

const { viewport, size } = useThree()

Most of the relevant calculations for margins, maxWidth and so on have been made in useBlock.

Handling async assets and loading screens via React.Suspense

Concerning assets, Reacts Suspense allows us to control loading and caching, when components should show up, in what order, fallbacks, and how errors are handled. It makes something like a loading screen, or a start-up animation almost too easy.

The following will suspend all contents until each and every component, even nested ones, have their async data ready. Meanwhile it will show a fallback. When everything is there, the <Startup /> component will render along with everything else.

<Suspense fallback={<Fallback />}>
<AsyncContent />
<Startup />

In three-fiber you can suspend a component with the useLoader hook, which takes any Three.js loader, then loads (and caches) assets with it.

function Image() {
const texture = useLoader(THREE.TextureLoader, “/texture.png”)
// It will only get here if the texture has been loaded
return (
<meshBasicMaterial attach=”material” map={texture} />

Adding shader effects and tying them to scroll

The custom shader in this demo is a Frankenstein based on the Three.js MeshBasicMaterial, plus:

the RGB-shift portion from DigitalGlitcha warping effect taken from Jesper Landbergand a basic UV-coordinate zoom

The relevant portion of code in which we feed the shader block-specific scroll data is this one:

material.current.scale =
lerp(material.current.scale, offsetFactor – top / ((pages – 1) * viewportHeight), 0.1)
material.current.shift =
lerp(material.current.shift, (top – last) / 150, 0.1)

Adding Diamonds

The technique is explained in full detail in the article Real-time Multiside Refraction in Three Steps by Jesper Vos. I placed Jesper’s code into a re-usable component, so that it can be mounted and unmounted, taking care of all the render logic. I also changed the shader slightly to enable instancing, which now allows us to draw dozens of these onto the screen without hitting a performance snag anytime soon.

The component reads out block-data like everything else. The diamonds are put into place according to the scroll offset by distributing the instanced meshes. This is a relatively new feature in Three.js.

Wrapping up

This tutorial may give you a general idea, but there are many things that are possible beyond the generic parallax; you can tie anything to scroll. Above all, being able to compose and re-use components goes a long way and is so much easier than dealing with a soup of code fragments whose implicit contracts span the codebase.

Scroll, Refraction and Shader Effects in Three.js and React was written by Paul Henschel and published on Codrops.

5 Tips For Buying a Used Flagship Smartphone

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/Pjhnil59_Bg/5-tips-for-buying-a-used-flagship-smartphone

Flagship smartphones denote that they are the best smartphone that has ever been created till date by the company. So, a flagship smartphone is equipped with the finest features and hardware. At the time of launch, these products are priced at a very high price, which makes it unaffordable to the masses. So, many users […]

The post 5 Tips For Buying a Used Flagship Smartphone appeared first on designrfix.com.

Apple Boxing Day sale 2019: All the best deals on Apple devices

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/A4JxEefGZHM/apple-boxing-day-sale-2019

Welcome to Creative Bloq's guide to the Apple boxing Day sale. If you held out over the pre-Christmas shopping events in the hopes of snapping up an even bigger discount in January, now's the time to get shopping. 

In this article you'll find all the best offers from the Apple Boxing Day sale. Digging out the best deals can be a daunting prospect – and let's face it, you're probably not functioning at your peak right now. We've split the deals into products, to make it much easier to navigate the Apple Boxing Day sale as you struggle through your carb coma / eggnog hangover / Quality Street stupor. After all, there's nothing worse than making a mistake and ordering the wrong thing, or checking out before finding the same thing cheaper elsewhere. Use the jump links to go straight to the Apple device you're looking for. 

The Apple Store isn't likely to be the best place to shop the Apple Boxing Day sale. You'll probably find bigger discounts at other retailers or – if you're not yet ready to leave you living room – online. 

Below is a list of the retailers that offered the biggest discounts over the pre-Christmas shopping events (Black Friday and Cyber Monday), so it's worth doing a quick check to see they're getting involved in the Apple Boxing Day sale too. Use the quick links below to take a look yourself, or scroll down for sales guide, broken down into products.

Amazon (US and UK)Best BuyWalmartVeryCurrys PC WorldAOLaptops Direct
Apple Boxing Day sale: iPad deals

In the pre-Christmas sales, we saw plenty of excellent iPad discounts across a whole range of models – including the all-new 10.2‑inch iPad. Check out the best prices in your region – including any Apple Boxing Day sale offers – using the widget below. Figuring out which is the best offer, taking into account the different models, storage options and features, can be difficult. Make sure you pay attention to the specs you're getting before you hit 'Add to cart'. 

Apple Boxing Day sale: MacBook deals

MacBooks are pretty much always in demand – mainly because, as designers will well know, this kind of top-quality kit doesn't come cheap. Luckily they're also often the target of big discounts, if you're on the ball and looking in the right places. Whether you're after a classic MacBook, a MacBook Air or MacBook Pro, chances are you'll be able to pick up a discounted model right now.

The price widgets below will display the best prices available right now, so you can see who's getting involved in the Apple Boxing Day sale. 

Apple has recently released a new MacBook Pro (read our MacBook Pro 16-inch review). While we might see deals on that model, based on what we saw in the Black Friday sales, we'd expect the best discounts in the Apple Boxing Day sale to be on slightly older models. If you're happy not having the latest, greatest MacBook then that's a good way to pick up a bargain. Another hot tip is to keep an eye out for refurbished models – there can be some hidden gems on pre-owned models.

We saw some okay (but not amazing) discounts on Apple Pencils in the run-up to Christmas. Will Apple's Boxing Day sale yield any better price cuts? Check out the widget below for the best prices right now.

Not sure which version you need? Explore our Apple Pencil vs Apple Pencil 2 comparison. 

Apple Boxing Day sale: AirPods deals

These are the headphones of the moment, and we saw a fair few good AirPod discounts in the run-up to Christmas, on both the original AirPods and the AirPods Pro. These true wireless earbuds aren't quite as new and exciting now (and there's a fair bit of competition hitting the market from people like Amazon and Microsoft). 

For the best prices in your area right now, including any gems from the Apple Boxing Day sale, check out the price widget below. Alternatively, explore our dedicated Apple AirPod deals guide.

There were plenty of Apple Watch offers in the run-up to the holidays, with the newly released Series 5 meaning retailers were happy to drop their prices to shift older stock. Check out the best prices right now – on the Series 5 as well as previous models – below. 

Apple Boxing Day sale: iMac and Mac deals
How to make the most of the Apple Boxing Day sale

To get the best deal possible, it's a good idea to plan ahead. Do your research and decide what product, model and specs will suit your needs. It's also best to have a price in mind that you're happy to spend. You don't want to end up being overwhelmed by the different Apple Boxing Day sale options and making the wrong decision, or overpaying. Once you've decided on the product you're after, you can start tracking its price on various retailers – or even simpler, bookmark this page and keep checking it. 

Read more:

Adobe deals: Where to get a Creative Cloud discount

Popular Design News of the Week: December 9, 2019 – December 15, 2019

Original Source: https://www.webdesignerdepot.com/2019/12/popular-design-news-of-the-week-december-9-2019-december-15-2019/

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.

PNGDB.com – Download Millions of Free PNG Images


Free Vector Illustrations for Web Designers


15 Tools Web Designers Should Try in 2020


People with Cool Avatars


New Levi’s Logo is Infuriating Typophiles


Why You Shouldn’t Use Solid or Underlined Text Fields


Leonardo: Contrast-based Color Generator


Accessibility Tips for Web Developers


17 Useful Tools for UI/UX Designers


Responsive Breakpoints Generator


18 Christmas Gifts for Designers


Sentence Lengths


Is it Possible to Draw the Internet?


Modern Brands Going Back to their Vintage Logos


Why CSS HSL Colors are Better!


10 Ways to Make a Fully Personalized UI


Mental Models for Designers


Introducing Unsplash for Brands


Investigating the Designer’s Aesthetic-Accessibility Paradox


Think You Can’t Escape Google? You Haven’t Seen Anything yet


Measuring User Experience with Usability Metrics


Why You Shouldn’t Ignore Smaller Web Design Projects


Branding is Dead, CX Design is King


Principles of Conversational Design


Why Systems Give You More Creativity


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


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

R/GA LookBook and Manifest of Management Principles

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/hKo4qDWBQuk/rga-lookbook-and-manifest-management-principles

R/GA LookBook and Manifest of Management Principles
R/GA LookBook and Manifest of Management Principles

abduzeedoDec 12, 2019

Ryan Atkinson and his team brief was to design a physical book to manifest our Management Principles. The Business Transformation team at R/GA (among many things) is known for it’s sneaker culture. And because they know that good managers make their people look good, they thought it only fitting to bring their sneaker culture and management principles together to create the BT Lookbook — A collection designed to help you find your own (management) style and put your best foot forward.

For the art direction of the photography we shot a “polaroid-in-the-moment” style to emphasize the concept of a fashion lookbook a little more. Hard shadows, hot lighting and even a bit of blur were all intentionally designed to reference powerhouse fashion magazines like self service.

Editorial Design

Check out Ryan’s Instagram

35 Coming Soon Pages For Your Inspiration

Original Source: https://www.hongkiat.com/blog/coming-soon-pages-for-your-inspiration/

One of the most important aspects of promotion is to create a hype of your product or service before it’s launch. In this respect, an interesting coming soon page can play an important role in…

Visit hongkiat.com for full content.