Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/3DiC7Od0Ejw/nike-air-max-720-illustration-typography

Nike Air Max 720 Illustration & Typography

AoiroStudio
Apr 13, 2018

Happy Friday guys! Already the end of the week and hope your week went pretty well. We are cooking with the idea for keeping Fridays entirely for you guys, we would pick projects that we have received from our community through Facebook or Instagram and feature them on ABDZ. Let’s start it off with the work of Wes L Cockx who is a 3D illustrator based in Brussels, Belgium. He is sharing his project about Nike Air Max 720 and it’s always amazing seeing artists making awesome work with 3D. Something that we dearly love on Abduzeedo, hope you will enjoy!

3D illustrations for Nike’s Air Max 270 Air by you release China, Air Max Day 2018. Lightness • Biggest Air • Movement • Innovation

More Links
Learn more about Wes L Cockx
Follow the work of Wes L Cockx on Behance
Illustration & Typography

Video

illustration
Typography
3d

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

Inspirational Website of the Week: Célia Lopez

A great design with some futuristic details and effects. Our pick this week.

Get inspired

Our Sponsor
Everything IT requires and Developers love

With a robust SDK, amazing support, detailed documentation, and super clean dashboard, HelloSign API is sure to make your team happy.

Try it today

Color: From Hexcodes to Eyeballs

Jamie Wong’s fantastic exploration of electromagnetic radiation, optical biology, colorimetry, and display hardware.

Read it

@keyframers 1.0.0

The @keyframers premier, where David Khourshid and Stephen Shaw live code an animation.

Watch it

Displaying the Weather With Serverless and Colors

Join Burke Holland in this fun project where he builds a weather bulb that shows a certain color based on the outside temperature.

Read it

Glide 3.0

The carousel library Glide has evolved into a dependency-free and light-weight script. Made by Jędrzej Chałubek.

Check it out

Brutalist design is the bad influence we all need

An interesting read by Maria Grilo where she explains Brutalist design.

Read it

Why React needed yet another animation library. Introducing: react-spring

Read all about react-spring, a new animation library for React. By Paul Henschel.

Read it

Free Font: Quiapo Free

A great brush typeface inspired by the signs hanged behind the windshield of Filipino jeepneys. By Aaron Amar.

Free Font

Geometric Letters

Alaa Alnuaimi designed this geometric font that reuses a small number of simple geometric shapes.

Check it out

ES6 Syntax and Feature Overview

An introduction to ES6 syntax and features, such as classes, Promises, constants, and destructuring, with one-to-one comparisons to older versions of JavaScript. By Tania Rascia.

Read it

Going Offline

Chapter 1 of Jeremy Keith’s new book “Going Offline”.

Read it

Sneak Peek at WebAssembly Studio

Learn about WebAssembly.Studio, an online IDE that helps you learn and teach others about WebAssembly.

Read it

The State of Web Animation

Megan Zlock explores the current state of web animations in this two part series. Check out part 1, too.

Read it

Productivity

A very interesting read on productivity by Sam Altman.

Read it

Fuzzball

Great three.js fun with David Lenaerts’ Fuzzball.

Check it out

Editorial Design and CSS Grid: Inspiration and examples

To illustrate (and celebrate) the approach between editorial design and web design, Ricardo Prieto has set out to design some pages of the 99U Quarterly Magazine with CSS Grid.

Read it

How CSS works: Parsing & painting CSS in the critical rendering path

Benjamin Johnson’s first article in a series where he takes a deep dive into exploring CSS as well as its attached ecosystem.

Read it

Moose

Great free stock photos that are made to fit together.

Check it out

Top JavaScript VSCode Extensions for Faster Development

Arfat Salman lists some great VSCode extensions he uses on a day-to-day basis.

Read it

Free Font: Atalanta

A strong display typeface designed by Jose Manuel Vega.

Get it

Memphis Space Seamless Patterns

Some gorgeous retro Memphis patterns made by Creative Veila.

Get it

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

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/HIyar2JWmOU/blockchain-cryptocurrency-workflow-2018

Bitcoin and Blockchain were the talk of the town (the town being the world!) in 2017. There was a lot of buzz around the sudden hike in the prices of Bitcoin and people from all walks of life invested a buck or two in the money-making scheme. While that was for Bitcoin in 2017, the […]

The post How Blockchain and Cryptocurrency Workflow in 2018 appeared first on designrfix.com.

Original Source: https://www.hongkiat.com/blog/download-free-sound-effects/

Best websites to download different kinds of music, sound effects, vocals, and audio snippets etc. for free.

The post 50+ Sites to Download Free Sound Effects for Almost Everything appeared first on…

Visit hongkiat.com for full content.

Original Source: https://www.sitepoint.com/es6-default-parameters/

Creating a method also means writing an API — whether it’s for yourself, another developer on your team, or other developers using your project. Depending on the size, complexity, and purpose of your function, you have to think of default settings and the API of your input/output.

Default function parameters and property shorthands are two handy features of ES6 that can help you write your API.

ES6 Default Parameters

Let’s freshen up our knowledge quickly and take a look at the syntax again. Default parameters allow us to initialize functions with default values. A default is used when an argument is either omitted or undefined — meaning null is a valid value. A default parameter can be anything from a number to another function.

// Basic syntax
function multiply (a, b = 2) {
return a * b;
}
multiply(5); // 10

// Default parameters are also available to later default parameters
function foo (num = 1, multi = multiply(num)) {
return [num, multi];
}
foo(); // [1, 2]
foo(6); // [6, 12]

A real-world example

Let’s take a basic function and demonstrate how default parameters can speed up your development and make the code better organized.

Our example method is called createElement(). It takes a few configuration arguments, and returns an HTML element. The API looks like this:

// We want a <p> element, with some text content and two classes attached.
// Returns <p class=”very-special-text super-big”>Such unique text</p>
createElement(‘p’, {
content: ‘Such unique text’,
classNames: [‘very-special-text’, ‘super-big’]
});

// To make this method even more useful, it should always return a default
// element when any argument is left out or none are passed at all.
createElement(); // <div class=”module-text default”>Very default</div>

The implementation of this won’t have much logic, but can become quite large due to it’s default coverage.

// Without default parameters it looks quite bloated and unnecessary large.
function createElement (tag, config) {
tag = tag || ‘div’;
config = config || {};

const element = document.createElement(tag);
const content = config.content || ‘Very default’;
const text = document.createTextNode(content);
let classNames = config.classNames;

if (classNames === undefined) {
classNames = [‘module-text’, ‘default’];
}

element.classList.add(…classNames);
element.appendChild(text);

return element;
}

So far, so good. What’s happening here? We’re doing the following:

setting default values for both our parameters tag and config, in case they aren’t passed (note that some linters don’t like parameter reassigning)
creating constants with the actual content (and default values)
checking if classNames is defined, and assigning a default array if not
creating and modifying the element before we return it.

Now let’s take this function and optimize it to be cleaner, faster to write, and so that it’s more obvious what its purpose is:

// Default all the things
function createElement (tag = ‘div’, {
content = ‘Very default’,
classNames = [‘module-text’, ‘special’]
} = {}) {
const element = document.createElement(tag);
const text = document.createTextNode(content);

element.classList.add(…classNames);
element.appendChild(text);

return element;
}

We didn’t touch the function’s logic, but removed all default handling from the function body. The function signature now contains all defaults.

Let me further explain one part, which might be slightly confusing:

// What exactly happens here?
function createElement ({
content = ‘Very default’,
classNames = [‘module-text’, ‘special’]
} = {}) {
// function body
}

We not only declare a default object parameter, but also default object properties. This makes it more obvious what the default configuration is supposed to look like, rather than only declaring a default object (e.g. config = {}) and later setting default properties. It might take some additional time to get used to it, but in the end it improves your workflow.

Of course, we could still argue with larger configurations that it might create more overhead and it’d be simpler to just keep the default handling inside of the function body.

Continue reading %Clean Code with ES6 Default Parameters & Property Shorthands%