50 Useful Android Apps for Designers (2018)

Original Source: https://www.hongkiat.com/blog/android-apps-designer/

Long list of Android apps that are useful for designers including photo editing and sharing, and social media apps along with others.

The post 50 Useful Android Apps for Designers (2018) appeared…

Visit hongkiat.com for full content.

Collective #430

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

C430_WOTW

Inspirational Website of the Week: An Interesting Day

No animations but a brilliant layout and a unique design with some nice details. Our pick this week.

Get inspired

C430_optin

Our Sponsor
Bloom: eMail Opt-In And Lead Generation Plugin For WordPress

Bloom gives you the power to display opt-in forms using integrations of the most popular email marketing systems available.

Check it out

C430_cms

Publii

Publii is a static-website-building tool for every skill level with a GUI to build a safe, fast and stylish website.

Check it out

C430_IEGrid

CSS Grid in IE: CSS Grid and the New Autoprefixer

Daniel Tonon’s three-part series on CSS Grid in Internet Explorer. In this second part he tackles the common misconception that the IE implementation of CSS grid is extremely difficult.

Read it

C430_feature

Introduction to Feature Policy

Learn everything about “Feature Policy” which allows web developers to selectively enable, disable, and modify the behavior of certain APIs and web features in the browser. By Eric Bidelman.

Read it

C430_subgrid

CSS Grid Level 2: Here Comes Subgrid

Rachel Andrew explains the new features of CSS Grid Level 2.

Read it

C430_cssdoodles

CSS Doodles

A lovely set of CSS doodles by Agathe Cocco.

Check it out

C430_generative

The Mutable Gallery

A collection of generative artworks by Heydon Pickering.

Check it out

C430_text

Textalytic

Textalytic is a free Natural Language Processing service that handles pre-processing, analyzing, and visualization in an easy to use web interface.

Check it out

C430_iconsystems

The guide to integrating and styling icon systems?- SVG sprites, SVG symbols and icon fonts

The second part in a two-part series on icon systems with focus on SVG image sprites, SVG symbols and icon fonts. By Sebastiano Guerriero.

Read it

C430_physics

Physics-Based Background Scroll Effects

In case you missed it: a tutorial on how to create an animated background effect with Matter.js.

Read it

C430_loading

Infinitely drawing icons

A great loading animation of icons by Mikael Ainalem.

Check it out

C430_clocks

Clock Shop

A collection of beautiful and unusual clock demos.

Check it out

C430_ab

The Link Bar, an Ecommerce Mobile Homepage Navigation Alternative (to the Hamburger Menu)

Some interesting AB test results of using the link bar navigation pattern in mobile sites.

Check it out

C430_forms

Beyond Likert scales: how we made boring form-filling more fun

Read how the team at JotForm made their forms more fun to use.

Read it

C430_cssart

picCSSel Art

A tool to create CSS pixel art made by Kushagra Gour.

Check it out

C430_ghost

Ghost Mouse

A fantastic demo by Liam Egan where a blob like element moves with the mouse/finger.

Check it out

C430_brads

Brad’s Homelab

Brad Fitzpatrick’s home lab setup for highly-available internet.

Check it out

C430_clearfix

Clearfix: A Lesson in Web Development Evolution

Jason Hoffman takes a look at the history of the famous CSS clearfix hack.

Read it

C430_svgterm

termtosvg

A Linux terminal recorder written in Python that renders your command line sessions as standalone SVG animations.

Check it out

C430_font

Free Font: Akrotiri

A playful rounded font made by Ilya Zakharov.

Get it

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

Better Collaboration By Bringing Designers Into The Code Review Process

Original Source: https://www.smashingmagazine.com/2018/07/collaboration-designers-code-review-process/

Better Collaboration By Bringing Designers Into The Code Review Process

Better Collaboration By Bringing Designers Into The Code Review Process

Ida Aalen

2018-07-10T13:50:26+02:00
2018-07-10T14:18:57+00:00

Smooth collaboration between developers and designers is something everyone aspires to, but it’s notoriously difficult. But with today’s advanced web, it’s difficult — if not impossible — to build a truly great product without collaborating across disciplines. Because of the range of technologies required to build a product, the product can only truly succeed when all disciplines — developers and designers, content creators, and user experience strategists — are deeply involved from the early stages of the project. When this happens, all ends of what it takes to build a product come naturally together into a unified whole, and a thus great product.

Because of this, no one is really promoting waterfall processes anymore. Nevertheless, involving other people early on, especially people from other disciplines, can feel scary. In the worst case scenario, it leads to “design by committee.”

Moreover, both designers and content strategists often have backgrounds in fields in which a sole creative genius is still the ideal. Having someone else proof your work can feel like a threat to your creativity.

So how can you involve people early on so that you’re avoiding the waterfall, but also making sure that you’re not setting yourself up for design by committee? I found my answer when learning about code reviews.

Getting workflow just right ain’t an easy task. So are proper estimates. Or alignment among different departments. That’s why we’ve set up “this-is-how-I-work”-sessions — with smart cookies sharing what works well for them. A part of the Smashing Membership, of course.

Explore features →

Smashing TV, with live sessions for professional designers and developers.

The Aha! Moment

In July 2017, I founded Confrere together with two developers, and we quickly hired our first engineer (I’m not a developer myself, I’m more of a UX or content designer). Our collaboration was running surprisingly smoothly, so much so that at our retrospectives, the recurring theme was that we all felt that we were “doing it right.”

Three people are smiling and sitting next to each other around a computer. From left to right, they are Dag-Inge (CTO), Ida (CPO) and Ingvild (Sr. Engineer).

Dag-Inge (CTO), myself (CPO) and Ingvild (Sr. Engineer). (Large preview)

I sat down with my colleagues to try to pinpoint what exactly it was that we were “doing right” so that we could try to preserve that feeling even as our company grew and our team expanded. We came to the realization that we all appreciated that the whole team was involved early on and that we were being honest and clear in our feedback to each other. Our CTO Dag-Inge added: “It works because we’re doing it as peers. You’re not being berated and just getting a list of faults”.

The word “peer” is what gave me the aha moment. I realized that those of us working within UX, design, and content have a lot to learn from developers when it comes to collaboration.

Peer reviewing in the form of code reviews is essential to how software gets built. To me, code reviews offer inspiration for improving collaboration within our own fields, but also a model for collaborating across fields and disciplines.

If you’re already familiar with code reviews, feel free to skip the next section.

What Is A Code Review?

A code review can be done in various ways. Today, the most typical form of code review happens in the way of so-called pull requests (using a technology called git). As illustrated below, the pull requests let other people on the team know that a developer has completed code that they wish to merge with the main code base. It also allows the team to review the code: they give feedback on the code before it gets merged, in case it needs improvement.

Pull requests have clearly defined roles: there is an author and a reviewer(s).

Ingvild and Dag-Inge is setting next to each other and smiling. An arrow indicated that Ingvild has sent code to Dag-Inge.

Ingvild (the author) requests a review from Dag-Inge (the reviewer). (Large preview)

As an example, let’s say our senior engineer Ingvild has made a change to Confrere’s sign-up flow. Before it is merged into the main code base and gets shipped, she (the author) creates a pull request to request a review from our CTO Dag-Inge (the reviewer). He won’t make any changes to her code, only add his comments.

Ingvild and Dag-Inge is setting next to each other. An arrow indicates that Dag-Inge has sent comments on code back to Ingvild.

Dag-Inge comments on Ingvild’s code. (Large preview)

It’s up to Ingvild how she wants to act on the feedback she received in the review. She’ll update her pull request with the changes she sees fit.

Ingvild and Dag-Inge are sitting next to each other. An arrow indicates that Ingvild is sending back her code to Dag-Inge, having looked through the code he commented on.

Ingvild updates her code with the changes she sees fit in light of Dag-Inge’s comments. (Large preview)

When the reviewer(s) approve the pull request, Ingvild can then merge her changes with the main code base.

Ingvild and Dag-Inge are sitting next to each other. A thumbs-up is displayed on the code review Dag-Inge has sent to Ingvild. And arrow indicates she pushes this code to the main repository.

After Dag-Inge gives the thumbs up, Ingvild can push the fix to production. (Large preview)

Why Bother Doing Code Review?

If you’ve never done code review, the process above might sound bureaucratic. If you have doubts, here’s a ton of blog posts and academic research about the advantages of code review.

Code reviews set the tone for the entire company that everything we do should be open to scrutiny from others, and that such scrutiny should be a welcome part of your workflow rather than viewed as threatening.

— Bruce Johnson, co-founder of Full Story

Code review reduces risk. Having someone proof your work, and also knowing someone will proof your work, helps weed out
 errors and
 heightens quality. In addition, it ensures consistency and helps every team member familiarize with more of the code base.

When done right, code review also builds a culture for collaboration and openness. Trying to understand and critique other people’s work is an excellent way to learn, and so is getting honest feedback on your work.

Always having at least two people look over the code also curtails ideas of “my” code 
and “your” code.
 It’s our code.

Considering these advantages, a review shouldn’t just be for code.

Review Principles For All Disciplines, Not Just Code

With reviews, there is always one author and one or more reviewers. That means you can involve people early on without falling into design by committee.

First, I have to mention two important factors which will affect your team’s ability to do beneficial reviews. You don’t necessarily have to have mastered them, but as a minimum, you should aspire to the following:

You and your colleagues respect each other and each other’s disciplines.
You’re sufficiently self-assured in your own role so that you feel like you can both give and receive criticism (this is also connected to the team’s psychological safety).

Even if we’re not reviewing code, there’s a lot to learn from existing best practices for code reviews.

Within our team, we try to adhere to the following principles when doing reviews:

Critique the work, 
not the author.
Be critical, but remain 
affable and curious.
Differentiate between a) Suggestions b) Requirements, c) Points that need discussion or clarification.
Move discussions from
 text to face-to-face. (Video counts)
Don’t forget to 
praise the good parts! What’s clever, creative, solid, original, funny, nice, and so on?

These principles weren’t actually written down until after we discussed why our collaboration was working so well. We all felt we were allowed to and expected to ask questions and suggest improvements already, and that our motivations were always about building something great together, and not about criticising another person.

Because we were being clear about what kind of feedback we were giving, and also remembered to praise each other’s good work, doing reviews was a positive force rather than a demotivating one.

An Example

To give you an idea of how our team uses review across disciplines and throughout a process, let’s look at how the different members of our team switched between the roles of author and reviewer when we created our sign-up flow.

Step 1: Requirements gathering

Author: Ida (UX)

Reviewers: Svein (strategy), Dag-Inge (engineering), Ingvild (engineering).

A whiteboard is showing rough sketches of a sign-up form. A man (Svein) and a woman (Ingvild) are smiling and discussing.

The team gathered around the whiteboard. Svein (CEO) to the left, Ingvild (Sr. Eng), to the right. (Large preview)

Whiteboard sessions can be exhausting if there’s no structure to them. To maintain productivity and creativity, we use the author/reviewer structure, even for something as seemingly basic as brainstorming on a whiteboard. In this case, in which we were coming up with the requirements for our sign-up flow, I got to be the author, and the rest of the team gave their feedback and acted as reviewers. Because they also knew they’d be able to review what I came up with in step 2 (plenty more opportunity for adjustments, suggestions, and improvements), we worked swiftly and were able to agree upon the requirements in under 2 hours.

Step 2: Mockup with microcopy

Author: Ida (UX)

Reviewers: Ingvild (engineering), Eivind (design), Svein (strategy).

A screenshot of a Google Doc mocking up a sign-up form with comments from team members Ingvild and Ida.

By mocking up in Google docs, it’s easy for people from all disciplines to provide feedback early on. (Large preview)

As an author, I created a mockup of the sign-up flow with microcopy. Did the sign-up flow make sense, from both the user and engineering perspective? And how could we improve the flow from a design and frontend perspective? At this stage, it was essential to work in a format in which it would be easy for all disciplines to give feedback (we opted for Google Docs, but it could also have been done with a tool like InvisionApp).

Step 3: Implementing the sign-up flow

Author: Ingvild (engineering)

Reviewer: Ida (UX) and Dag-Inge (engineering).

We had agreed upon the flow, the input fields, and the microcopy, and so it was up to Ingvild to implement it. Thanks to Surge, we can automatically create preview URLs of the changes so that people who can’t read code are able to give feedback at this stage as well.

Step 4: User testing

Author: Ida (UX)

Reviewer: The users.

Two women (Ida and a user) sitting next to eachother in front of a laptop.

Ida doing user testing on a small budget. (Large preview)

Yes, we consider user testing a form of review. We brought our newly built sign-up flow face-to-face with actual users. This step gave us a ton of insight, and the most significant changes in our sign-up flow came as a result.

Step 5: Design

Author: Eivind (design)

Reviewers: Ingvild (engineering) and Ida (UX).

A screenshot from Slack. Eivind, the designer, has posted a screenshot, and Ida replies with enthusiasm.

The first version of the sign-up flow was based on existing design components. In this stage, Eivind developed some new components to help improve the design. (Large preview)

When design suddenly shows up here in step 5, it might look a lot like a waterfall process. However, our designer Eivind had already been involved as a reviewer since step 2. He gave a bunch of useful feedback at that stage and was also able to start thinking about how we could improve the design of the sign-up flow beyond the existing modules in our design system. At this step, Eivind could also help solve some of the issues that we identified in the user testing.

Step 6: Implementation

Author: Ingvild (engineering)

Reviewer: Eivind (design), Ida (UX) and Dag-Inge (engineering).

And then we’re back to implementing.

Why review works

In summary, there’s always just one author, thus avoiding design by committee. By involving a range of disciplines as reviewers early on, we avoid having a waterfall process.

People can flag their concerns early and also start thinking about how they can contribute later on. The clearly defined roles keep the process on track.

Regular Review Walkthroughs

Taking inspiration from code walkthroughs, we also do regular review walkthroughs with different foci, guided by the following principles:

The walkthrough is done together.
One person is in charge of reviewing and documenting.
The idea is to identify issues, not necessarily to solve them.
Choose a format that gives as much context as possible, so that it’s easy to act upon the findings later (e.g. InvisionApp for visual reviews, Google Docs for text, and so on).

We’ve done review walkthroughs for things such as accessibility audits, reviewing feature requests, auditing the implementation of the design, and doing heuristic usability evaluations.

When we do our quarterly accessibility reviews, our accessibility consultant Joakim first goes through the interface and documents and prioritizes the issues he’s found in a shared Google Sheet. Joakim then walks us through the most important issues he’s identified.

Meeting face-to-face (or at least on video) to go through the issues helps create an environment for learning rather than a feeling of being supervised or micromanaged.

Three people in a sofa gathered around a laptop. They’re discussing and smiling.

Accessibility review: Joakim (right) walks Ingvild and Dag-Inge through the accessibility issues he found in his audit. (Large preview)

If you find yourself always being tied up with something that’s due for release, or fixing whatever is at the top of your inbox, reviews can help remedy that. If you set aside regular half days for reviewing work you’ve already done, you can identify issues before they become urgent. It can also help you refocus and make sure you’re priorities are keeping along the right lines. Your team should maybe not begin building that new feature before you’re confident that the existing features are living up to your standards.

User Testing Is A Form Of Review

An important motivation for code reviews is to reduce risk. By doing it every single time you introduce a change or add something new to your product, and not just when you suspect something is maybe not up to par, you diminish the chance of shipping bugs or subpar features. I believe we should look at user testing from the same perspective.

You see, if you want to reduce the risk of shipping with major usability issues, user testing has to be part of your process. Just having your UX designers review the interface isn’t enough. Several studies have found that even usability experts fail in identifying every actual usability problems. On average, 1 in 3 issues identified by experts were false alarms — they weren’t issues for users in practice. But worse, 1 in 2 issues that users did in fact have, were overlooked by the experts.

Skipping user testing is just as big a risk as skipping code review.

Does Review Mean Death To Creativity?

People working within design, user experience, and content often have educational backgrounds from art schools or maybe literature, in which the sole creator or creative artistic genius is hailed as the ideal. If you go back in history, this used to be the case for developers as well. Over time, this has changed by necessity as web development has grown more complex.

If you cling to the idea of creativity coming from somewhere deep within yourself, the idea of review might feel threatening or scary. Someone meddling in your half-finished work? Ouch. But if you think about creativity as something that can spring from many sources, including dialogue, collaboration, or any form of inspiration (whether from the outside or from someplace within you), then a review is only an asset and an opportunity.

As long as we’re building something for the web, there’s no way around collaborating with other people, be it within our own field or others. And a good idea will survive review.

Let’s create something great together.

Smashing Editorial
(rb, ra, yk, il)

97% Off: Get the Youtube Mastery Bundle for Only $41

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/RT1vETle2PA/youtube-mastery-bundle

Youtube is the second largest social media platform, with over a billion monthly active users. In fact, almost of one-third of internet users visit Youtube regularly. If you’re reading this blog post, chances are you have thought of creating your own Youtube channel. But with such an oversaturated platform, it can be difficult to gain […]

The post 97% Off: Get the Youtube Mastery Bundle for Only $41 appeared first on designrfix.com.

Collective #428

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

C428_WOTW

Inspirational Website of the Week: 2018 Foosball World Cup

A fantastic table football implementation for this year’s soccer world cup. Our pick this week.

Get inspired

C428_Udemy

Our Sponsor
Need a course to broaden your skill set?

From web dev beginners courses to accelerated JavaScript training, Udemy has something for everyone. Learn basically anything and discover new skills and passions.

Pick your course

C428_face

face-api.js

A JavaScript API for face detection and face recognition in the browser implemented on top of the Tensorflow.js core API.

Check it out

C428_gradients

Drawing Images with CSS Gradients

An in-depth tutorial on how to use CSS gradients to draw complex shapes by Jon Kantner.

Check it out

C428_currentstate

Current state of webdesign

Will you realize what this is about in less than 3 seconds? ?

Check it out

C428_gobelins

Heraclos

The magical final WebGL project by students of GOBELINS Paris.

Play it

C428_layoutlab

The Experimental Layout Lab

Jen Simmons relaunched her labs section and added some more demos that show the possibilities of CSS Grid.

Check it out

C428_backspace

Backspace Rethought

Louis Anslow shares a brilliant idea for backspace using the drag interaction.

Read it

C428_babel

On Consuming (and Publishing) ES2015+ Packages

A very interesting article by Henry Zhu how the community might move to a “post-ES5” package ecosystem.

Read it

C428_menu

CodePen Challenge: Menu

A fun, bouncy menu created by Adam Kuhn.

Check it out

C428_audiovis

Plexus Shaders

A futuristic WebGL music visualizer made with Three.js together with Vertex Shaders and Fragment Shaders.

Check it out

C428_mkcert

mkcert

A simple tool for making locally-trusted development certificates without requiring any configuration.

Check it out

C428_sass

How and Why We Unit Test Our Sass

Lindsey Wild shares how unit testing Sass code is done at Sparkbox.

Read it

C428_font

Free Font: Kalpazan

Vladimir Fedotov shares one of the styles of his new font family “Kalpazan”.

Get it

C428_ml5js

ml5.js

A library that aims to make machine learning approachable for a broad audience of artists, creative coders, and students. It provides access to machine learning algorithms and models in the browser, building on top of TensorFlow.js with no other external dependencies.

Check it out

C428_shapesdesandro

Solids

Some 3D magic by Dave DeSandro using the <canvas> drawing API.

Check it out

C428_painting

The Garden of Earthly Delights by Jheronimus Bosch

A beautiful, interactive documentary that provides an in-depth tour though “The Garden of Earthly Delights” painting.

Check it out

C428_icons

150 Free Vector Icons

A great set of beautifully designed and versatile vector icons in three different styles. By Elmira Gokoryan.

Get it

C428_truchet

Truchet

Amazing experiments in GLSL Truchet tiling and patterns by Liam Egan.

Check it out

C428_stationary

Stationery Branding & Identity Mockup (PSD)

A modern stationery and identity branding mockup by the folks of GraphicPear.

Get it

C428_500

Thank You

Liam Egan celebrates his 500 Codepen followers mark with this beautiful demo.

Check it out

C428_RevealSlideshow

From Our Blog
Triple Panel Reveal Slideshow

A fullscreen image slideshow with lateral image previews and a reveal animation using TweenMax.

Check it out

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

Using Puppeth, the Ethereum Private Network Manager

Original Source: https://www.sitepoint.com/puppeth-introduction/

We’ve previously written about Geth, one of the most popular Ethereum nodes.

Download screen

When you install Geth with helper tools, it comes with a handy tool called Puppeth, which you can use to maintain and install various helper tools for managing and deploying your private blockchain. Puppeth can also be installed independently if you have Go installed, with the following command:

go get github.com/ethereum/go-ethereum/cmd/puppeth

Let’s take a look at the tool.

Note: this tutorial will require you to have two remote machines at your disposal. Whether that is a virtual machine like Homestead Improved or an actual server on your network, or a combination of the two, doesn’t matter. We’ll go through the setup procedure with VMs in this tutorial.

Note: due to a bug in Puppeth, this approach might not work if your virtual machines (see below) are too small. Either make bigger VMs (more RAM) or wait for a fix if that’s not an option.

Bootstrapping

We’ll follow this process to get two virtual machines up and running. We need two machines because we’ll be running two Ethereum nodes, each on its own IP address.

Note: This is a limitation of Puppeth, as it’s not possible to deploy a sealing node on the same machine using this tool.

If you don’t know what Vagrant is, and what tools we’re using here, we recommend you read this introduction to Vagrant, which breaks it down in a newbie-friendly way.

mkdir my_project; cd my_project
git clone https://github.com/swader/homestead_improved hi_puppeth1
git clone https://github.com/swader/homestead_improved hi_puppeth2

Change the IP address of the second clone by going into the hi_puppeth2 folder and modifying the IP address field to be 192.168.10.11 instead of 192.168.10.10.

Next, open up some ports on the VMs by modifying each clone’s Homestead.yaml’s final section, like so:

ports:
– send: 8545
to: 8545
– send: 30301
to: 30301
– send: 30302
to: 30302
– send: 30303
to: 30303
– send: 30304
to: 30304
– send: 30305
to: 30305
– send: 30306
to: 30306

Don’t forget to add these virtual hosts into your host machine’s /etc/hosts file as well. Otherwise the VMs won’t be accessible by their domain name!

192.168.10.10 homestead.test
192.168.10.11 puppethnode.test

Note: change the IP addresses if the addresses of your VMs differ.

Finally, run vagrant up; vagrant ssh to boot each machine and SSH into it. Remember to run this from two separate tabs so you can keep both machines open and running.

Prerequisites

Now let’s install the prerequisite software on each machine.

Puppeth runs helper applications and Ethereum nodes for you in Docker containers, so we need Docker. It’s also useful to install Geth itself.

sudo add-apt-repository -y ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install
apt-transport-https
ca-certificates
curl
software-properties-common
ethereum
docker.io
docker-compose

All other prerequisites will be pulled in by Puppeth through docker itself, but we need to make sure the current user is allowed to operate Docker commands first:

sudo usermod -a -G docker $USER

On the host machine (outside the VMs), we should create new Ethereum accounts in the folder where we’re running our project.

If you’re using the VMs as suggested above, that can be in myproject if myproject is the parent folder which contains hi_puppeth1 and hi_puppeth2.

mkdir node1 node2
geth –datadir node1 account new
geth –datadir node2 account new

Make a note of the addresses generated by this process:

$ mkdir node1 node2
$ geth –datadir node1 account new
INFO [05-20|10:27:20] Maximum peer count ETH=25 LES=0 total=25
Your new account is locked with a password. Please give a password. Do not forget this password.
Passphrase:
Repeat passphrase:
Address: {aba88be2dc16eaed464e3991eed5a1eaa5e7b11b}
$ geth –datadir node2 account new
INFO [05-20|10:27:35] Maximum peer count ETH=25 LES=0 total=25
Your new account is locked with a password. Please give a password. Do not forget this password.
Passphrase:
Repeat passphrase:
Address: {655a6ea9950cdf9f8a8175fda639555f17277bdf}

We need two accounts because at least two signers are needed in a Proof of Authority blockchain (more on that later).

Puppeth

Now that our VMs are running and our accounts are initialized, let’s see what Puppeth offers. With the remote servers/VMs still running, in a new tab on your host machine run Puppeth with puppeth.

The first thing it’ll ask for is the network name. This is useful for identifying various blockchains if you’re running several on your local machine. We’ll use “puptest” here.

Please specify a network name to administer (no spaces or hyphens, please)
> puptest

Sweet, you can set this via –network=puptest next time!

INFO [05-20|10:32:15] Administering Ethereum network name=puptest
WARN [05-20|10:32:15] No previous configurations found path=/Users/swader/.puppeth/puptest

Now let’s connect to our “remote” servers so that Puppeth has them in the list and can do operations on them.

The post Using Puppeth, the Ethereum Private Network Manager appeared first on SitePoint.

How to Plan a Website Overhaul in 2018

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/HCRVANLXSI4/how-to-plan-a-website-overhaul-in-2018

It’s 2018, and you know what that means. Time for a website overhaul! Sure, if you’ve been building, managing, and growing websites long enough, then the thought of a website or a logo redesign will probably scare you away. Overhauling a website is just one of those things that cause more headaches and ruins by adding a […]

The post How to Plan a Website Overhaul in 2018 appeared first on designrfix.com.

Collective #427

Original Source: http://feedproxy.google.com/~r/tympanus/~3/iuLw0R-AdHg/

C424_Hello

This content is sponsored via Syndicate Ads
HelloSign API: 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 free today

C427_Lept

Lepto

A tool for automated image editing, optimization and analysis via CLI and a web interface.

Check it out

C427_devtube

DevTube

A collection of all developer and technical videos in one place.

Check it out

C427_keyframers

Movable Mountains

Watch David Khourshid and Stephen Shaw code up a beautiful parallax scroll effect using CSS and some JavaScript.

Watch it

C427_origami

Rabbit Ear

Rabbit Ear is an interesting JavaScript library for designing origami. By Robby Kraft.

Check it out

C427_access

Accessibility inspector

Read all about Firefox’s accessibility inspector which helps visualizing information exposed to assistive technologies on a web page, allowing you to check what’s missing or needs attention.

Read it

C427_calli

Animate Calligraphy with SVG

Claus Colloseus shows a great technique for animating calligraphic SVG “strokes”.

Read it

C427_uikit

Stream UI Kit

A beautiful open source Bootstrap 4 UI kit.

Get it

C427_githubedu

GitHub Education

GitHub’s new project that aims to make it possible for schools to adopt GitHub and their education offerings. Read more about it in this article.

Check it out

C427_summericons

Tropical Icon Set (PNG, SVG)

A fun seasonal icon set designed by Freepik for Speckyboy.

Get it

C427_githunt

IssueHunt

A funding platform for open-source maintainers and contributors.

Check it out

C427_fontalpha

Free Font: Alpha

Callum Finn designed this interesting minimal display font.

Get it

C427_gameboy

Game boy running zelda links awakening intro

Fantastic demo made by Karl Patrik Johansson.

Check it out

C427_animations

Web Animations in WebKit

Read how Safari Technology Preview 59 will have Web Animations turned on by default.

Read it

C427_globe

Gio.js

Gio.js is an open source library for 3D globe data visualization built with Three.js

Check it out

C427_icons

BoxIcons

A carefully crafted open source icon set with more than 350 icons.

Get it

C427_svg

Using Custom Fonts With SVG in an Image Tag

Thomas Yip explains how to use Nano for SVG optimization.

Read it

C427_portfolio

Simple Portfolio

A super simple way to instantly generate your portfolio website.

Check it out

C427_jelly

Bendy Drinks Menu

A jelly scroll menu by Chris Gannon.

Check it out

C427_font

Free Font: 3-D Sketch

A playful, hand-drawn display font made by Linseed Studio.

Get it

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

How to draw a big cat with pastels

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/6EAg0WMujUg/draw-a-big-cat-with-pastels

The softness and luminosity of pastel sticks make them the ideal choice for backgrounds in my pastel drawings; whereas pastel pencils (when sharpened to a fine point) have two types of lead for precision: hard and soft. However, I personally find these attributes are not as important as colour range. 

How to draw a landscape with pastels

I work mainly from photographs. This allows me to make any changes to the drawn composition should I wish to do so. In choosing this particular shot, I was able to capture a sense of the tiger's presence, which I try to convey with all my work. Not only did it present great tonal values, but also areas of really dark contrast against the lighter shades. The combination of these aspects always makes for a great painting.

As I select my colours ready for my painting, I use spare pieces of Pastelmat as testers to find the correct shades I wish to use. Once I've started, I never use a colour I have not already selected, as a small amount of a new shade would stand out in the painting. I always use Pastelmat for my pastel work – the combination of this surface with pastel pencils is ideal for showing off the effectiveness of the medium. 

For this piece, I use the following materials:

Anthracite Pastelmat 360 gsmWinsor & Newton Artists' Soft Pastels (for the background)Hard Conté sticks (for the underpainting)Pastel pencils including Derwent, Faber-Castell and Caran D'acheConté 630 White for the whiskersA HB Pencil for sketching
01. The original drawing 

Don’t put too much detail into your initial sketch

I use a general HB pencil to sketch the scene. I avoid a great deal of detail as I tend to remove the lines, using an eraser after transferring it to the Pastelmat. The lines show through the pastel using tracedown paper. 

02. Start from a focal point

sketch of tiger with eyes filled in

Grab the viewer’s attention by starting with the eyes

I always start with the eye area as this is the focal point to any animal portrait painting. I begin with the white highlights first, and then add the palest colours proceeded by the darker shades in and around the pupil. Following the pupil, I leave gaps in the blackness of the eyelid for the white fur to drop down. 

I always find it's best to establish some of the tiger's black stripes in advance, as the white fur sits over the top of its edges. Next, I apply the green and ochre hues over the white in light fine strokes, finally continuing with the orange across the nose area. This area is then worked from dark to light – all using pastel pencils.

03. Establish head shape

tiger's head in sketch

Work in a background edge first to show up the fine hairs

Having established a starting point, I continue above the eye area. I apply a background edge using a soft pastel in black, to account for all the fine hairs that run off the tiger's contour – especially around the ears. After edging the ear from orange, ochre then to cream, the centre is a layer of black, ochre and green all smudged together. I then draw in lots of fine white curly lines, topped with a layer of green and cream. The lines are random, but run in the direction of the tiger's form and shape.

04. Colour the cheek

tiger painting half done

Build up the side of the head, working in the direction of the fur

Continuing with the side of the head, I use oranges, ochres, and creams once again, noting that the layers of fur are running downwards. I work on the section directly underneath the eye using greens and greys first. I then use white to cover the coloured layers using wavy lines, exposing the original underpainting. I add green to the whiter area, then lastly, I add a layer of orange – ready for the nose. 

05. Get the nose right

tiger painting with nose

Take time to ensure that you capture the nose’s structure properly

The nose area is the most challenging as its structure spreads out into various directions. The line work runs above the eye, across at the bridge of the nose and curves in a downward stroke half way across the width of the nose, leaving a small triangular patch sitting centrally, just underneath the bridge. I follow this to the tip of the nose, using small light strokes of ochre and cream, continuing with darker shades in a circular motion to the side for depth. 

As I reach the fleshy part of the nose, I use grey before edging off in white, then I'm ready to apply the palest of pinks for the nose. Before applying the highlight of white, I add a dash of crimson and ochre, finishing off with black for the nostril. 

06. Work on muzzle and mouth

tiger painting with muzzle and mouth

Don’t forget the whiskers!

I now begin working around the cat's muzzle, putting in all the black areas first, sweeping in with the white at a diagonal angle. However, I make sure to leave space for the whiskers, which I drew in with Conté 630 White. I then work on the shadow areas using grey and green in the lower corner of the bottom lip over the black. 

I now need to create a 2D effect on the teeth, so I paint a mixture of ochre and yellow on the backs of the teeth. Moving towards the middle, I paint in a yellow towards the front, then a cream on the bottom half, with a white at the tip of the teeth. Once I'm happy with the result, I blend a small amount of pink into the black behind the teeth. I then proceed to the chin, which is all fine strokes of white, plus yellow, green and grey for the shadow areas.

07. Focus on underpainting

Tiger portrait with hard pastel sticks

Use hard pastel sticks for your underpainting

Having completed the main facial features, I now move onto the underpainting. This is not only a great way to define colour values and contrast, but also adds depth and body. Without it, the image would appear flat and lifeless. With the use of hard pastel sticks, I establish where the lights and darks are in my painting. This prepares the base ready for the details, which are drawn over the top in pastel pencil. 

08. Add layers

long fur close up of tiger painting

Give your picture depth by adding in layers of longer fur

In this step, I paint the longer fur between the face and neck. Starting with the black stripe first, I quickly move onto the white layers, rubbing them lightly into the Pastelmat's base, as I add a layer of yellow and ochre part way through. Shamrock and grey in the shadow areas keep the luminosity in the pastel layers fresh and transparent. Finally, I add fine, light spontaneous strokes, some more heavy than others.

09. Emphasise contrast

tiger painting with contrast added

Bring in further depth by emphasising the tiger’s natural contrasts

I start with the darkest area, the middle section, so that I can build my colours from dark to light bearing in mind where the contrast is. I lay down black first – for the stripes as well as the shadow area. I then work towards the top with a barely visible, very dark orange. I use a golden yellow to highlight the edges of the fur and a lemon with an upward stroke as the fur reaches the top of the tiger. The highlight is cream, with several white strokes done with an edging of tiny orange pencil marks. 

The bottom pattern is a bit tricky: I use orange into cream at a diagonal angle, flicking the pencil out at the bottom edges and blending for a natural look. I add black and grey between each shape, running into white near the bottom.

10. Create the background

tiger painting with black background

Add a black background then soften it with orange, green and cream

For the background, I cover the Pastelmat in a soft black pastel, which I rub in using an artist's sponge. I then work in a mixture of orange, green and cream directly to the side of the cat to add a warmth in the shadows – still using soft pastels with a circular motion.

This article was originally published in Paint & Draw.

Related articles:

How to add drama to your pastel artworksCarbOthello Pastel Pencil Set (24) reviewHow to fix your finished pastel artwork

How To Create A Flat Vector Illustration In Affinity Designer

Original Source: https://www.smashingmagazine.com/2018/07/flat-vector-illustration-affinity-designer/

How To Create A Flat Vector Illustration In Affinity Designer

How To Create A Flat Vector Illustration In Affinity Designer

Isabel Aracama

2018-07-11T20:00:02+02:00
2018-07-12T11:08:58+00:00

(This is a sponsored post.) If you are in the design world, chances are that you’ve already heard about Affinity Designer, a vector graphics editor for Apple’s macOS and Microsoft Windows.

It was July 2015 when Serif Europe launched the amazing software that many designers and illustrators like me are using now as their main tool for professional work. Unlike some other packages, its price is really affordable, there’s no subscription model and, as mentioned already, it’s available for both Macs and PCs.

In this article, I would like to walk you through just some of its very user-friendly main tools and features as an introduction to the software and to show you how we can create a nice flat vector illustration of a Volkswagen Beetle. The illustration will scale up to whatever resolution and size needed because no bitmaps will be used.

Note: As of today, July 11, Affinity Designer is also available for the iPad. Although the iPad app’s features and functionality almost completely match the desktop version of Affinity Designer, it relies much more on using the touch screen (and the Apple Pencil) and because of that, you may expect to find some differences in the workflows.

Final image that we’ll be creating in this tutorial.

Final image that we’ll be creating in this tutorial. (View large version)

I will also explain some of the decisions I take and methods I follow as I work. You know the old saying, “All roads lead to Rome”? In this case, many roads will take us where we’d like to get to, but some are better than others.

We will see how to work with the Pen tool to trace the main car outline, how to break curves and segments, how to convert objects into curves, and how to use the wonderful Corner tool. We will also, among other things, learn how to use the Gradient tool, what is a “Smart copy”, how to import a color palette from an image that we can use as a reference for our artwork, how to use masks, and how to create a halftone pattern. Of course, along the way, you will also learn some helpful keyboard shortcuts and commands.

Note: Affinity Designer has three work environments, referred to as “personas”. By default, Affinity Designer is set to the draw persona. To switch from the draw persona to the pixel persona or to the export persona, you have to click on one of the three icons located in the top-left corner of the main window. You can start working in the draw persona and switch to the pixel persona at any time, when you need to combine vectors and bitmaps.

The three work environments: draw persona (leftmost icon), bitmap persona (middle icon) and export persona (rightmost icon).The three work environments: draw persona (leftmost icon), bitmap persona (middle icon) and export persona (rightmost icon). (View large version)

Introduction: The Flat Design Era

In recent years, we’ve seen the rise of “flat design”, in contrast to what is known as skeuomorphic representation in design.

To put it simply, flat design gets rid of the metaphors that skeuomorphic design uses to communicate with users, and we’ve seen these metaphors in design, especially in user interface design, for years. Apple had some of the best examples of skeuomorphism in its early iOS and app designs, and today it is widely used in many industries, such as music software and video games. With Microsoft’s (with Metro) and later Google’s material design and Apple’s iOS 7, mobile apps, user interfaces and most systems and OS’ have moved away from skeuomorphism, using it or elements of it as mere enhancements to a new design language (including gradients and shadows). As you can imagine, illustrations on these systems were also affected by the new design currents, and illustrators and designers started creating artwork that would be consistent with the new times and needs. A whole new world of flat icons, flat infographics and flat illustrations opened in front of our eyes.

iPhone’s home screen (iOS 6 versus iOS 7).

iPhone’s home screen (iOS 6 versus iOS 7). (View large version)

(Image source) (View large version)

(Image source) (View large version)

(Image source) (View large version)

(Image source) (View large version)

Let’s Draw A Flat Illustration!

I am providing here the source file for this work, so you can use it to explore it and to better follow along as we design it. If you do not yet have a copy of Affinity Designer, you can download a trial.

1. Canvas Settings

Open Affinity Designer, and create a new document by clicking Cmd + N (Mac) or Ctrl + N (Windows). Alternatively, you can go to “Menu” → “File” → “New”. Be sure not to check the “Create Artboard” box.

Set the type to “Web”, which will automatically set the field DPI to 72. It should be understood now as PPI, but we won’t dive into the details here. If you want to learn more on the topic, check the following two resources:


It’s PPI not DPI,” Forums, Affinity

“PPI vs. DPI: What’s the Difference?,” Alex Bigman, 99designs

Also, remember that you can change this setting at any time. The vectors’ quality won’t be affected by scaling them.

Set the size to 2000 × 1300 pixels, and click “OK”.

Our white canvas is now set, but before we start, I’d suggest you first save this file and give it a name. So, go to “File” → “Save”, and name it “Beetle”.

2. Importing A Color Palette From An Image

One of the things I use a lot in Affinity Designer is its ability to import the colors contained in an image and creating a palette from them.

Let’s see how this is done.

For the illustration I want to draw, I thought of warm colors, like in a sunset, so I searched Google with this query: “warm colors yellows oranges reds palette”. From all the images it found, I chose one that I liked and copied it into Affinity Designer in my recently created canvas. (You can copy and paste the image to the canvas directly from the browser.)

If the Swatches panel isn’t open yet, use menu “View” → “Studio” → “Swatches”. Click the menu in the top-right corner of the panel, and select the option “Create Palette From Document”, and then click on “As Document Palette”. Click “OK” and you’ll see the colors contained in the image form a new palette in the Swatches panel. The default name for it will be “Palette” if you still haven’t saved your file with a name. In case you have, the name of this palette will be the same as your document, but if you want to rename it, simply go to the menu on the right in the Swatches panel again and select the option “Rename Palette”.

I will call it “Beetle Palette”.

Creating a palette from an image.

Creating a palette from an image. (View large version)

We can now get rid of that reference image, or simply hide it in the Layers panel. We will be using this palette as a guide to create our artwork with harmonious colors.

Interface: Before we continue, I will present a quick overview of the main sections of the user interface in Affinity Designer, and the names of some of the most used tools.

Main areas of the UI in Affinity Designer when using the draw persona.

Main areas of the UI in Affinity Designer when using the draw persona. (View large version)

Tools for the (default) draw persona in Affinity Designer.

Tools for the (default) draw persona in Affinity Designer. (View large version)

3. Creating The Background With The Gradient Tool

The next thing is to create a background. For this, go to the tools displayed on the left side, and select the Rectangle tool. Drag it along the canvas, making sure to give it an initial random fill color so that you can see it. The fill color chip is located in the top toolbar.

Click the Rectangle tool and drag it along the canvas. Fill it with a random color.

Click the Rectangle tool and drag it along the canvas. Fill it with a random color. (View large version)

Next, select the Fill tool (the color wheel icon, or press G on the keyboard), and in the top Context toolbar, select the type: “Linear”.

Select “Linear” from the Fill tool’s contextual menu.

Select “Linear” from the Fill tool’s contextual menu. (View large version)

We have several options here: “None” removes the fill color, “Solid” applies one solid color, and all of the rest are different types of gradients.

To straighten the gradient and make it vertical, place your cursor over one of the ends and pull. When you are near the vertical line, press Shift: This will make it perfectly vertical and perpendicular to the base of the canvas.

To straighten a linear gradient, pull from one end, and then press the Shift key to make it perfectly vertical.To straighten a linear gradient, pull from one end, and then press the Shift key to make it perfectly vertical. (View large version)

Next, in the Context toolbar, click on the color chip, and you’ll see a dialog that corresponds exactly with the gradient we just applied. Click now on the color chip, and an additional dialog will open.

In the combo, click on the “Color” tab, and then select “RGB Hex Sliders”; in the field marked with a #, input the value: FE8876. Press “OK”. You’ll see now how the gradient has been updated to the new color. Repeat this action with the other color stop in the gradient dialog, and input this value: E1C372.

You should now have something like this:

Setting gradient colors.

Setting gradient colors (View large version)

Let’s go to the Layers panel and rename the layer to “Background”. Double-click on it to rename it, and then lock it (by clicking on the little lock icon in the top-right corner).

4. Drawing The Car Outline With The Pen Tool

The next thing we need to do is look for an image that will serve as our reference to draw the outline of the car. I searched Google for “Volkswagen Beetle side view”. From the images I found, I selected one of a green Beetle and copied and pasted it into my document. (Remember to lock the layer with the reference image, so that it doesn’t move accidentally.)

Next, in the side toolbar, select the Pen tool (or press P), zoom in a bit so that you can work more comfortably, and start tracing a segment, following the outline of the car in the picture. Give the stroke an 8-pixel width in the Stroke panel.

Note: You won’t need to create a layer, because the segments you trace will be automatically placed on top of the image.

The Pen tool is one of the most daunting tools for beginners, and it is obviously one of the most important tools to learn in vector graphics. While practice is needed to reach perfection, it is also a matter of understanding some simple actions that will help you use the tool better. Let’s dive into the details!

As you trace with the Pen tool in Affinity Designer, you will see two types of nodes: squared nodes appear first, and as you pull the handles, they will turn into rounded nodes.

Sharp, smooth nodes and handles on a path segment

Sharp, smooth nodes and handles on a path segment (View large version)

Affinity Designer comes with several pen modes, but we will only be using the default one, called “Pen Mode”, and as we trace the car, we will get rid of one of the handles by clicking Alt in such a way that the next section of the segment to be traced will be independent of the previous one, even if connected to it.

Here’s how to proceed. Select the Pen tool, click once, move some distance away, click a second time (a straight line will be created between nodes 1 and 2), drag the second node (this will create a curve), Alt-click the node to remove the second control handle, then proceed with node 3, and so on.

An alternative way would be to select the Pen tool, click once, move some distance away, click a second time (a straight line will be created between nodes 1 and 2), drag the second node (this will create a curve), then, without moving the mouse, Alt-click the second handle’s point to remove this handle, then proceed with node 3, and so on.

Trace the outline of the car and get rid of the handles we don’t need by Alt-clicking.Trace the outline of the car and get rid of the handles we don’t need by Alt-clicking. (View large version)

Note: Don’ be afraid to trace segments that are not perfect. With time, you’ll get a better grip of the Pen tool. For now, it’s not very important that each node and line looks as we want it to look in the end. In fact, Affinity Designer makes it really easy to amend segments and nodes, so tracing a rough line to start is just fine. For more insight on how to easily use the Pen tool (for beginners), check out Isabel Aracama’s video tutorial.

5. Resculpting Segments And Using The Corner Tool

What we need now is to make all of those rough lines look smooth and curvy. First, we will pull the straight segments to smoothen them, and then we will improve them using the Corner tool.

Click the Node tool in the side toolbar, or select it by pressing A on your keyboard. Now, start pulling segments to follow the lines of your reference picture. You can also use the handles to help make the line take the shape you need by moving and pulling them accordingly. Just do it in such a way that it all fits the reference image, but don’t bother much if it’s not yet perfect. With the Node tool (A), you can both select and move nodes, but you can also click and drag the curves themselves to change them.

Resculpt and correct segments with the Node tool A.Resculpt and correct segments with the Node tool (A). (View large version)

Once all of the segments are where we need them, we are going to smoothen their corners using the Corner tool (shortcut: C). This is one of my favorite tools in Affinity Designer. The live Corner tool allows you to adjust your nodes and segments to perfection. Select it by pressing C, or select it from the Tools sidebar. The method is pretty simple: Pass the corner tool over the sharp nodes (squared nodes) that you want to smoothen. If you need to, switch back to the Node tool (A) to adjust a section of a segment by pulling it or its handles. (Smooth nodes (rounded nodes) don’t allow for more softening, and they will display a smaller circle the moment you select the Corner tool.)

View large version

View large version

Use the Corner tool on sharp nodes to smoothen the lines.Use the Corner tool on sharp nodes to smoothen the lines. (View large version)

Once our corners and segments look good, we’ll want to fill the shape and change the color of the stroke. Select the closed curve line that we just created for the car, click on the fill color chip, and in the HEX color field input FFCF23. Click on the stroke color chip beside it and input 131000.

This is what you should have after applying the fill color and stroke color.

This is what you should have after applying the fill color and stroke color. (View large version)

Create now a shape with the Pen tool, and fill it with black (000000). Place it behind the car’s bodywork (the yellow shape). The exact shape of the new object that you will create does not really matter, except that its bottom side needs to be straight, as in the image below. Place it behind the main bodywork (the yellow shape) via either the Layers panel or through the menu “Arrange” → “Back One”.

Black shape behind the car bodywork.

Black shape behind the car bodywork (View large version)

6. Creating The Wheels Using Smart Copy

We need to put the wheels in place next. In the Tools, pick the Ellipse tool, and drag over the canvas, creating a circle the same size as the wheel in the reference picture. Click Shift as you drag to make the circle proportionate. Additionally, holding Ctrl (Windows) or Cmd (Mac), you can create a perfect circle from the center out.

Note: If you need to, hide the layers created thus far to see better, or simply reduce their opacity temporarily. You can change the opacity by selecting any shape and pressing a number on the keyboard, from 1 to 9, where 1 will apply a 10% opacity and 9 a 90% opacity value. To reset the opacity to 100%, press 0 (zero).

Choose a random color that contrasts with the rest. I like to do so initially just so that I can see the shapes well contrasted and differentiated. When I am happy with them, I apply the final color. Set the opacity to 50% (click 5 on the keyboard) to be able to see through as you draw it.

Zoom into your wheel shape. Press Z to select the Zoom tool, and drag over the shape while holding Alt key, or double-click on the thumbnail corresponding to it in the Layers panel. (It doesn’t need to be previously selected, although this will help you to visually locate it in the Layers panel.)

We will now learn how to use Smart copy, and we will paste some concentric circles.

Select the circle and press Cmd + J (Mac) or Ctrl + J (Windows). A new circle will be placed on top of the original one. Select it. This command is found under “Edit” → “Duplicate”, and it’s also known as Smart copy or Smart duplicate.

Click Shift + Cmd (Mac) or Shift + Ctrl (Windows), and drag in to transform it into a smaller concentrical circle. Repeat three times, reducing a bit more in size each time, to fit your reference. Smart duplicating a shape by pressing Shift + Cmd (Mac) or Shift + Ctrl (Windows) will make the shape transform in a relative way. This will happen from your third smart-duplicated shape onwards.

smart copy via keyboard shortcutsSmart copy via Cmd + J or Ctrl + J. (View large version)

So, we have our concentric circles for the wheel, and now we have to change the colors. Go to the Swatches panel, and in the previously created palette, choose colors that work well with the yellow that we have applied to the car’s bodywork. You can select a color and modify it slightly to adapt to what you think works best. We need to apply fill and stroke colors. Remember to give the stroke the same width as the rest of the car (8 pixels) except for the innermost circle, where we will apply a stroke of 11.5 pixels. Also, remember to put back to 100% the opacity of each concentric circle.

I chose these colors, from the outer to inner circles: 5D5100, 918A00, CFA204, E5DEAB.

Now we want to select and group all of them together. Select them all and press Cmd + G (Mac) or Ctrl + G (Windows). Name the new group “Front Wheel” in the Layers panel. Duplicate this group and, while pressing Shift, select it and drag along the canvas until it overlaps with the back wheel. Name the layer accordingly.

The car should look similar to this now.

The car should look similar to this now. (View large version)

7. Breaking Curves And Clipping Masks To Draw The Inner Lines Of The Car’s Bodywork

To keep working, either hide all layers or bring down the opacity so that they don’t get in your way. We need to trace the front and back fenders. We have to do the same as what we did for the main bodywork. Pick the Pen tool and trace an outline over it.

Once it is traced, modify it by using the handles, nodes and Corner tool. I also modified the black shape behind the car a bit, so that it shows a bit more in the lower part of the body work.

Fenders added to the car.

Fenders added to the car. (View large version)

Now we want to trace some of the inner lines that define the car. For this, we will duplicate the main yellow shape, remove its fill color and place it onto our illustration in the canvas.

Press A on the keyboard, and click on any of the bottom nodes of the segment. In the top Context toolbar, click on “Action” → “Break Curve”. You will see now that the selected node has turned into a red-outlined squared node. Click on it and pull anywhere. As you can see, the segment is now open. Click the Delete or Backspace key (Windows) or the Delete key (Mac), and do the same with all of the bottom nodes, leaving just the leftmost and rightmost ones, and also being very careful that what is left of the top section of the segment is not deformed at all.

(View large version)

I use this method for one main reason: Duplicating an existing line allows for a more consistent look and for more harmonious lines.

Select now the newly opened curve, and make it smaller in such a way that it fits into the main yellow shape when you place them on top of one another. In the Layers panel, drag this curve into the yellow shape layer to create a clipping mask. The reason for creating a clipping mask is simple: We want an object inside another object so that they do not overlap (i.e. both objects are visible), but one nested inside the other. Not doing so would result in some bits of the nested object being visible, which is not what we want; we need perfect, clean-cut lines.

Note: Clipping masks are not to be mistaken for masks. You will know you’re clipping and not masking because of the thumbnail (masks show a crop-like icon when applied) and because when you are about to clip, a blue stripe is displayed horizontally, a bit more than halfway across the layer. Masks, on the other hand, display a small vertical blue stripe beside the thumbnail.

Clipping versus masking in Affinity Designer

Clipping versus masking in Affinity Designer (View large version)

Clipping mask once it is appliedClipping mask once it is applied (View large version)

Now that we have applied our clipping mask to insert the newly created segment inside the main shape of the car, I’ve broken some nodes and moved some others around a bit in order to place them exactly how I want. I’ve stretched the width a bit, and separated the front from the rest of the segment using exactly the same methods we’ve already seen. Then, I applied a bit more Corner tool to soften whatever I felt needed to be softened. Finally, with the Pen tool, I added some extra nodes and segments to create the rest of the inner lines that define the car.

Note: In order to select an object in a mask, a clipping mask or a group when not selecting the object directly in the Layers panel, you have to double-click until you select the object, or hold Ctrl (Windows) or Cmd (Mac) and click.

Adding extra lines to a segment.Adding extra lines to a segment (View large version)

After some amendments and tweaking using the mentioned methods, our car looks like this:

How the car looks after a little tweaking of the segments and nodes

How the car looks after a little tweaking of the segments and nodes (View large version)

8. Drawing The Windows Using Some Primitive Shapes

In the side Toolbar, select the Rounded Rectangle tool. Drag on the canvas to create a shape. The size of the shape should fit in the car’s bodywork and look proportionate. No matter how you create it, you will be able to resize it later, so don’t worry much.

Note: When you create a shape with strokes and resize it, be sure to check “Scale with object” in the Stroke panel if you want the stroke to scale in proportion with the object. I recommend that you visually compare the difference between having this option checked and unchecked when you need to resize an object with a stroke.

Make sure this is checked if you plan to resize your artwork, so that it scales the strokes accordingly.

Make sure this is checked if you plan to resize your artwork, so that it scales the strokes accordingly. (View large version)

Once you have placed your rounded rectangle on the canvas, fill it with a blue-ish colour. I’ve used #93BBC1. Next, select it with the Node tool (press A). You will now see a little orange circle in the top-left corner. If you pull outwards or inwards, you’ll see how the angle in that corner changes. In the top Context toolbar, you can uncheck “Single radius”, and apply the angle you want to each corner of the rectangle individually. Uncheck it, and pull inwards on the tiny orange circle in the top-left corner. If you pull, you will be able to round it to a certain percentage, but you can also input the desired value in the input field for it, or even use the slider it comes with (it will show whether you’ve clicked on the little chevron). Let’s apply a value of 100%.

View large version

How the rounded rectangle primitive shape looks in default mode and how it changes when we uncheck the single radius box. Now we can manipulate the corners individually.

How the rounded rectangle primitive shape looks in default mode and how it changes when we uncheck the single radius box. Now we can manipulate the corners individually. (View large version)

Primitive shapes are not so flexible in terms of vector manipulation (compared to curves and lines), so, in order to apply further changes to such a shape (beyond fill, stroke, corners, width and height), we will need to convert it to curves.

Note: Once you convert a primitive shape into curves, there is no way to go back, and there will be no option to manipulate the shape through the little orange stops. If you need further tweaking, you will need to do it with the Corner tool.

Select the rectangle with the Node tool (A), and in the top Context toolbar, click the button “Convert to Curves”. The bounding box will disappear, and all of the nodes forming the shape will be shown. Also, note how in the Layers panel, the name of the object changes from “Rounded Rectangle” to “Curve”.

Now you need to manipulate the shape in order to create an object that looks like a car window. Look at the reference picture to get a better idea of how it should look. Also, tweak the rest of the drawn lines in the car, so that it all fits together nicely. Don’t worry if the shapes don’t look perfect (yet). Getting them right is a matter of practice! Using the Pen tool, help yourself with the Alt and Shift keys and observe how differently the segment nodes behave. After you have created the front window, go ahead and create the back one, following the same method.

We also need to create the reflections of the window, which we’ll do by drawing three rectangles, filling them with white color, overlapping them with a bit of offset from one another, and setting the opacity to 50%.

Place the cursor over the top bounding-box white circle, and when it turns into a curved arrow with two ends, move it to give the rectangles an angle. Create a clipping mask, dragging it over the window shape in the Layers panel as we saw before. You can also do this by following the following alternative methods:

Under the menu “Layer” → “Insertion” → “Insert Inside” the selected window object.

With the keyboard shortcut Ctrl + X (Windows) and Cmd + X (Mac), select your window object → “Edit” → “Paste Inside” (Ctrl/Cmd + Alt + V).

Repeat this for the back window. To add visual interest, you can duplicate the reflections and slightly change the rectangles’ opacities and widths.

Create the reflections on the windows, and clip them inside.Create the reflections on the windows, and clip them inside. (View large version)

9. Adding Visual Interest: Halftone Pattern, Shadows And Reflections

Before we start with the shadows and reflections, we need to add an extra piece onto the car so that all of the elements look well integrated. Let’s create the piece that sits below the doors. It is a simple rectangle. Place it on the corresponding layer order, so that it looks like the picture below, and keep inserting all of the pieces together so that it looks compact. I will also move a bit the front fender to make the front shorter.

The car, once the final bodywork pieces have been placed and tweaks made. We’re getting there!

The car, once the final bodywork pieces have been placed and tweaks made. We’re getting there! (View large version)

Now let’s create the halftone pattern.

Grab the Pen tool (P) and trace a line on your canvas. In the Stroke panel (you can also do this in the Pen tool’s Context toolbar section for the stroke, at the top), set the size to something like 7 pixels. We can easily change this value later if needed. Select the “Dash” line style, and the rest of the dialog settings should be as follows:

Settings for the first part of creating the halftone pattern.

Settings for the first part of creating the halftone pattern. (View large version)

Now, duplicate this line, and place the new one below with a bit of an offset to the left.

View large version

Group both lines, duplicate this group with a Smart copy, and create something like this:

Smart copy the first two lines, and create the whole pattern.

Smart copy the first two lines, and create the whole pattern. (View large version)

When you drag a selection in Affinity Designer, only objects that are completely within the selection area will be selected. If you want to select all objects without having to drag over all of them completely, you have the following options:

Mac: Holding the ⌃ (Ctrl) key will allow you to select all objects touching the selection marquee as you draw it.

Windows: Click and hold the left mouse button, start dragging a selection, and then click and hold the right mouse button as well. As you are holding both buttons, all objects touching the selection marquee will be selected.

Alternatively, you can make this behavior a global preference. On Mac, go to “Affinity Designer” → “Preferences” → “Tools”, and check “Select object when intersects with selection marquee”. On Windows, go to “Edit” → “Preferences” → “Tools”, and check “Select object when intersects with selection marquee”.

To make the illustration more interesting, we are going to vary the beginning and end of some of the lines a bit. To do this, we select the Node tool (A), and move the nodes a bit inwards.

It should now look like this:

View large version

To apply the pattern to our design, make sure everything is grouped, copy and paste it into our car artwork, reduce its opacity to 30%, and also reduce the size (making sure “Scale with object” is checked in the Stroke panel). We will then create a clipping mask. It is important to keep consistency in the angle, color and size of this pattern throughout the illustration.

Applying the halftone mask.Applying the halftone mask (View large version)

Now, apply the halftone pattern to the back fender and to the car’s side; make sure to create a placeholder for it first, be it the fender itself or a new shape. Make some tweaks if you need to adapt the pattern to your drawing in a harmonious way. You can change the overall size, the dots’ size, the transparency, the angle and so on, but try to be consistent when applying these changes to the pattern bits.

For the shadow below the windows, I drew a curve to be the placeholder, and applied the color #CFA204 so that it looks darker.

10. Creating The Remaining Elements Of The Car

Now, it’s all about creating the rest of the elements that make up the car: the bumpers, the back wheel and the surf board, plus the design stickers.

The front and back lights
For the front light, switch to the Segment tool and draw the shape. Then we need to rotate it a bit and place it somewhere below the car’s main bodywork. The same can be done for the back light but using the Rectangle tool. The colors are #FFDA9D for the front light and #FF0031 for the back light.

Creating the front lightCreating the front light (View large version)

Surfboard
To create the surfboard, we will use the Ellipse tool and draw a long ellipse. Convert it to curves and pull up the lower segment, adjusting a bit the handles to give it the ideal shape.

Creating the surf boardCreating the surf board (View large version)

Now, just create two small rounded rectangles, with a little extra line on top for the board’s rack. Place them in a layer behind the car’s main body shape.

Board rack pieces

Board rack pieces (View large version)

With the Pen tool, add the rudder. Its color is #B2E3EF. And for the stroke, use a 6-pixel width and set the color to #131000.

Spare wheel
Now let’s create the the spare wheel! Switch to the Rounded Rectangle tool. Drag over the canvas to draw a shape. Color it #34646C, and make the stroke #131000 and 8 pixels in size. The size of the spare wheel should fit the proportions of your car and should have the same diameter as the other wheels, or perhaps just a bit smaller. Pull the orange dots totally inwards, and give it a 45-degree angle. For the rack that holds the wheel, create a small piece with the Rectangle tool, and give it the same 45-degree angle, color it #4A8F99, and make the stroke #131000 and 4.5 pixels in size. Create the last piece that rests over the car in the same way, with a color of #34646C, and a stroke that is #131000 and 4.5 pixels in size.

Lastly, let’s create a shadow inside the wheel to add some more interest. For this, we’ll create a clipping mask and insert an ellipse shape with a color of #194147, without a stroke.

Note: We may want to create the same shadow effect for the car wheels. Use the Rectangle tool and a color of #312A00, create a clipping mask, and insert it in the wheel shape, placing it halfway.

Three simple shapes to draw the spare wheel and its rack

Three simple shapes to draw the spare wheel and its rack (View large version)

Bumpers
For the bumpers, we will apply the boolean operation “add” to two basic shapes and then clip-mask a shadow, just as we did for the wheels.

Boolean operations are displayed in the section of icons labeled “Geometry” (Mac) and “Operations” (Windows). (Yes, the label names are inconsistent, but the Affinity team will likely update them in the near future, and one of the labels will become the default for both operating systems.) If you don’t see them in the upper toolbar, go to “View” → “Customize Toolbar”, and drag and drop them into the toolbar.

Important: If you want the operation to be non-destructive, hold the Alt key while clicking on the “Add” icon (to combine the two basic shapes).

Boolean operations: Add, Subtract, Intersect, Divide, Combine.

Boolean operations: Add, Subtract, Intersect, Divide, Combine. (View large version)

Applying the (destructive) Add operation to create a single shape from two shapes.

Applying the (destructive) Add operation to create a single shape from two shapes. (View large version)

Note: If you try to paste the “shadow” object inside the bumper, it will only work if the bumper is one whole object (a destructive operation). So, if you used Alt + “Add”, this will not work now. However, you can still work around this by converting the Compound shape (the result of a non-destructive operation that is a group of two objects) to one Curve (one whole vector object). You just need to click on the Compound shape, then in the menu go to “Layer” → “Convert to Curves” (or use the key combination Ctrl + Enter).

Back window
We are still missing the back window, which we will create with the Pen tool, and the decoration for the car. For the two colored stripes, we need the Square tool and then clip-mask these two rectangles into the main bodywork. The size is 30 × 380 pixels, and the colors are #0AC8CE and #FF6500. Clip them by making sure you’ve put them on the right layer, so that the dark lines we drew before are above them.

Number 56
For the number “56” decoration, use the Artistic Text tool (“T”), and type in “56”. Choose a nice font that matches the style of the illustration, or try the one I’ve used.

The color for the text object is #FFF3AD.

(I added an extra squared shape behind the back fender, which will look like the end of the exhaust pipe. The color is #000000.)

Color strips
Now that we’ve done this, check the color stripes and the window they overlap with. As you can see (and because we put some transparency in the window glass), the orange stripe is visible through it. Let’s use some Boolean power again to fix this.

Bumpers and exhauster added. Check out the overlapped window and the orange stripe!

Bumpers and exhauster added. Check out the overlapped window and the orange stripe! (View large version)

Duplicate the window object. Select both the window object (the one you just duplicated) and the orange stripe in the Layers panel. Apply a “subtract” operation.

Stage 1, before the subtract operation.

Stage 1, before the subtract operation. (View large version)

tage 2, once the subtract operation is applied.

Stage 2, once the subtract operation is applied. (View large version)

Now, the orange stripe has the perfect shape, fitting the window in such a way that they don’t overlap.

Stripe and window with subtraction operation applied.

Stripe and window with subtraction operation applied. (View large version)

Smoke
To create the smoke from the exhaust, draw a circle with a white stroke, 5.5 pixels in size and no fill. Transform it to curves and break one of its points. From the bottom node, trace a straight line with the Pen tool.

Duplicate this “broken” circle, and resize to smaller circles, and flip and place them so that they look like this:

Creating the exhaust smoke

Creating the exhaust smoke (View large version)

Note: Now that the car is finished, group all of its layers together. It will be much easier to keep working if you do so!

11. Creating The Ground And The Background Elements.

Ground
Let’s trace a simple line for the ground, and add two bits breaking it in order to create visual interest and suggest a bit of movement. We also want to add an extra piece to create the ground. For this, we will use the Rectangle tool and draw a rectangle with a gradient color of #008799 for the left stop and #81BEC7 for the right stop. Give it 30% opacity.

Gradient for the ground piece and the grouped car layers for a clean view in the Layers panel.

Gradient for the ground piece and the grouped car layers for a clean view in the Layers panel. (View large version)

Clouds
For the clouds, select the Cloud tool from the list of (primitive) vector shapes. Draw a cloud by holding Shift to keep the proportions. Make it white. Transform it into curves, and with the Node tool (A) select the bottom nodes and delete them. Sub-select the bottom-left and bottom-right nodes (after deleting all of the others), and then in the Context toolbar, select “Convert to Sharp” in the Convert section. This will make your bottom segment straight. Apply some transparency with the Transparency tool (Y), and duplicate this cloud. Place the clouds in your drawing, spread apart as you wish and in different sizes.

My clouds have 12 bubbles and an inner radius of 82%. You can do the same or change these values to your liking.

Creating the clouds with the Cloud tool and the Transparency toolCreating the clouds with the Cloud tool and the Transparency tool (View large version)

Palm trees
To create the palm trees, use the Crescent tool from the list of primitive shapes on the left. Give it a gradient color, with a left stop of #F05942 and a right stop of #D15846.

Drag to draw the crescent shape. Move its center of rotation to the bottom of the bounding box, and give it a -60-degree angle.

The center of rotation can be made visible in the Contextual toolbar section for the Move (and Node) tool. It looks like a little crosshair icon. When you click on it, the crosshair for moving the rotation center of an object will show. Duplicate it, either via Cmd + C and Cmd + V (Mac) or Ctrl + C and Ctrl + V (Windows), or by clicking and then Alt + dragging on the object, and move the angle of the new crescent to -96 degrees. Make it a bit smaller. Copy the two shapes and flip them horizontally.

I also created and extra crescent.

Creating the palm leavesCreate the palm leaves (View large version)

To create the indentations on the leaves, transform the object to curves, add a node with the Node tool, and pull inwards. To make the vortex sharp, use “Convert” → “Sharp”.

Creating the leaves’ indentationsCreating the leaves’ indentations (View large version)

Create the trunk of the palm tree with the Pen tool, group all of the shapes together, and apply an “add” boolean. This way, all of the shapes will transform into just one. Apply a 60% opacity to it.

The palm tree once the Add boolean operation has been applied.

The palm tree once the Add boolean operation has been applied (View large version)

Duplicate the tree shape several times, changing the sizes and tweaking to make the trees slightly different from one another. (Making them exactly the same would result in a less interesting image.)

The last thing we need to make is the sun.

The sun
For this, simply draw an ellipse and apply a color of #FFFFBA to it. Apply a transparency with the Transparency tool (Y), where the bottom is transparent and gets opaque at the top.

Transparency applied to the sun shape

Transparency applied to the sun shape (View large version)

Now we will add some detail by overlapping several rounded rectangles over the sun circle and subtracting them (click Alt for a non-destructive action, if you prefer).

Applying a subtract operationApplying a subtract operation (View large version)

Place your sun in the scene, and we are done!

12. A Note On The Stacking Order (And Naming Of Layers)

While you work, and as the number of objects (layers) grows, which will also make your illustration more and more complex, keep in mind the stacking order of your layers. The sooner you start naming the layers and placing them in the right order, the better. Also, lock those layers that you’re done with (especially for things such as the background), so that they don’t get in the way as you work.

In this illustration, the order of elements from bottom to top is:

background,
ground,
sun,
clouds,
palm trees,
car.

Conclusion

I hope you could follow all of the steps with no major problems and now better understand some of Affinity Designer’s main tools and actions. (Of course, if you have some questions or need help, leave a comment below!)

These tools will allow you to create not only flat illustrations, but many other kinds of artwork as well. The tools, actions and procedures we’ve used here are some of the most useful and common that designers and illustrators use daily (including me), be it for simple illustration projects or much more complex ones.

However, even my most complex illustrations usually need the same tools that we’ve seen in action in this tutorial! It’s mainly a matter of understanding how much you can get out of each tool.

Remember the few important tips, such as locking the layers that could get in your way (or using half-transparency), stacking the layers in the right order, and naming them, so that even the most complex of illustrations are easy to organize and work with. Practice often, and try to organize things so that your workflow improves — this will lead to better artwork and better time management as well.

Also, to learn more about how to create this type of illustration, check out the video tutorial that I posted on my YouTube channel.

The completed Volkswagen Beetle illustration.

The completed Volkswagen Beetle illustration. (View large version)

Smashing Editorial
(mb, ms, ra, yk, al, il)