Cool App: Unsplash Wallpapers for Mac and Android

Original Source:

Cool App: Unsplash Wallpapers for Mac and Android

Cool App: Unsplash Wallpapers for Mac and Android

Oct 12, 2017

We are sharing a cool app by the mighty folks from Unsplash. Having shared their API a couple weeks ago, they created an easy-to-use app for all of us. It’s very easy, forget the days where you used to download the wallpaper and playing with your screen settings. Within a few clicks, there you have it with a new/fresh wallpaper. Wanna try it out, get it now.

Cool App: Unsplash Wallpapers for Mac and AndroidUnsplash Wallpapers for Mac and Android

In their words

Which is why we’re so consistently awestruck at Unsplash. How do Unsplash contributing photographers capture so much staggering beauty — and with such incredible regularity, too? Are they actual magicians? If you strike up a conversation with one of them (like we are fortunate enough to get to do) you realize it all comes down to a love for capturing moments.

Of all the ways that Unsplash photos get used, the biggest one is definitely wallpapers. ‘Black mirrors’ are everywhere so it’s no wonder one of our most popular Unsplash collections is for desktop wallpaper and iOS/Android lock screen art. We wanted to make the process of getting Unsplash wallpaper even easier — skipping the manual labour of downloading photos and playing with your screen settings.

More Links
Learn more about Unsplash Wallpapers
Get the Unsplash Wallpapers via Mac App Store
Get the Unsplash Wallpapers via Google Play
App Gallery
Cool App: Unsplash Wallpapers for Mac and AndroidCool App: Unsplash Wallpapers for Mac and Android


web apps

How to Use Warnings and Errors in Sass Effectively

Original Source:

The following is a short extract from our book, Jump Start Sass, written by Hugo Giraudel and Miriam Suzanne. It’s the ultimate beginner’s guide to JavaScript. SitePoint Premium members get access with their membership, or you can buy a copy in stores worldwide.

Our incredible journey through Sass is slowly coming to an end, and so far you’ve been doing great! There’s one technical chapter left before we look at project architecture, and then you’ll be fully equipped to write Sass code in your own projects.

Now we’re going to look at warnings and errors. Both form a one-way communication system between the program (in this case, Sass) and the developer (you). If you’re wondering about the point of errors in the CSS world, remember that you already know the answer. Whenever you forget a semicolon or use a function incorrectly, Sass throws an error at you, explaining what you’ve done wrong and how you can fix it, thankfully! It would be a real pain to have to dig into the code to figure out what’s gone wrong.

Sass has long provided a way to emit warnings from stylesheets, but it’s only recently added support to throw errors as well—and for good reason! Over the last few years, Sass has allowed authors to build complex systems to abstract difficult or repetitive patterns and concepts, such as grids. These systems must be able to communicate with authors, stopping the compilation process with a custom error message if anything ever goes wrong.

Both warnings and errors are emitted in the current output channel. When compiling Sass by hand or by using a tool through a command line interface (CLI) such as Grunt or Gulp, the output stream is the console. For tools that include a user interface, such as Codekit or Prepros, it’s likely that they catch and display warnings and errors as part of their interface. Online playgrounds such as CodePen and SassMeister manage to catch errors but not warnings, so don’t be alarmed if you’re unable to test them in there.


As has been stated, the ability to emit warnings in Sass is not new. It’s possible to display messages or the value of any SassScript expression to the standard output stream through the @warn directive.

A warning has no impact on the compilationprocess; it does not prevent compiling to pursue or change it in any way. Its only purpose is to display a message in the console.

There are a lot of reasons to use warnings in Sass. Here are a couple, but you’re likely to find your own:

informing the user of an assumption made about the code in order to avoid surprise and hard-to-track bugs
advising about a deprecated function or mixin as part of a library or framework

Sending a warning is dead simple to do: start with the @warn directive, then state whatever it is. Warnings are usually made to provide some information and context, so they often feature a sentence explaining the situation. That being said, you don’t have to use a string; you can warn with a number, a list, a map—whatever. Here, we print a string:

@warn ‘Uh-oh, something looks weird.’;

Using a regular CLI client, this warning will emit the following output:

WARNING: Uh-oh, something looks weird.
on line 1 of /Users/hgiraudel/jump-start-sass/warning.scss

Hey, that’s nice, isn’t it? Although this warning is far from helpful. It says that something looks weird but does not say what, why, or what can be done to stop it from looking weird. We’ll discuss how we can improve on warnings further on.

Let’s move on to a more serious example now that we know how to use he feature. Imagine we have a Sass custom function that attempts to convert a pixel value in em unit:

@function px-to-em($value, $base-font-size: 16px) {
@return ($value / $base-font-size) * 1em;

// Usage
.foo {
font-size: px-to-em(42px); // 2.625em

All good. Now, what happens when passing a unitless number—such as 42—to the function? Maybe you’ve guessed it, but as it’s not quite obvious I’ll give you the answer:

2.625em/px isn’t a valid CSS value.

This happens because you’re trying to perform a calculation between incompatible units (px and em). What we could do to circumvent this issue is assume the unitless value be expressed in pixels and convert it first:

@function px-to-em($value, $base-font-size: 16px) {
@if unitless($value) {
@warn ‘Assuming value `#{$value}` to be in pixels; attempting to convert it.’;
$value: $value * 1px;


@return ($value / $base-font-size) * 1em;

The function is expecting a value expressed in pixels. We can still make it work with a unitless value; however, we cannot be sure that this is the expected behavior. We can only assume that it’s good enough.

Because we’re assuming what is the correct behavior for our function, it’s important to let the developer know what we’re doing and why. Otherwise it could lead to bugs that are hard to track, which is not
what you should be aiming for.

Another practical example would be to warn against the usage of a deprecated function or mixin. You might have already heard of or used Bourbon, a lightweight mixin library for Sass. Bourbon is actively maintained, and sometimes requires removing helpers from the library. To avoid suddenly breaking a person’s ode, Bourbon warns about future deprecations way before it actually removes mixins:

@mixin inline-block {
display: inline-block;

@warn ‘The `inline-block` mixin is deprecated and will be removed in the next major version release.’;

Clever! People who still use the inline-block mixin from Bourbon are aware that the library will remove it completely in the next version, so they know to start updating their codebase to remove the mixin.

The Difference between @warn and @debug

You may or may not be familiar with the @debug directive, which prints the value of a SassScript expression to the standard output stream in the same fashion as @warn. You might be wondering why there are two features performing the same task, and what could possibly be the difference between the two.

Continue reading %How to Use Warnings and Errors in Sass Effectively%

4 Web Design Tips to Make Video Content More Effective

Original Source:

Many websites nowadays have video content of some form or other due to how effective it can be. However in some cases that effectiveness is hindered by the fact that the design of the website doesn’t take into account the unique nature of videos, and ends up hindering it rather than helping.   Assuming you’d […]

The post 4 Web Design Tips to Make Video Content More Effective appeared first on

5 Common Mobile App Development Mistakes You Should Never Make

Original Source:

Forrester predicted that 46% of the global population will use smartphones by the end of 2016 and they were spot on. According to Neilson report, 89% of the time spent on smartphones is spent in using mobile apps. According to Google, 25% of mobile apps are never used while 26% of mobile apps are abandoned […]

The post 5 Common Mobile App Development Mistakes You Should Never Make appeared first on

JavaScript Functions That Define and Rewrite Themselves

Original Source:

The following is a short extract from our new book, JavaScript: Novice to Ninja, 2nd Edition, written by Darren Jones. It’s the ultimate beginner’s guide to JavaScript. SitePoint Premium members get access with their membership, or you can buy a copy in stores worldwide.

The dynamic nature of JavaScript means that a function is able to not only call itself, but define itself, and even redefine itself. This is done by assigning an anonymous function to a variable that has the same name as the function.

Consider the following function:

function party(){
console.log('Wow this is amazing!');
party = function(){
console.log('Been there, got the T-Shirt');

This logs a message in the console, then redefines itself to log a different message in the console. When the function has been called once, it will be as if it was defined like this:

function party() {
console.log('Been there, got the T-Shirt');

Every time the function is called after the first time, it will log the message “Been there, got the T-Shirt”:

<< 'Wow this is amazing!'

<< 'Been there, got the T-Shirt'

<< 'Been there, got the T-Shirt'

If the function is also assigned to another variable, this variable will maintain the original function definition and not be rewritten. This is because the original function is assigned to a variable, then within the function, a variable with the same name as the function is assigned to a different function. You can see an example of this if we create a variable called beachParty that is assigned to the party() function before it is called for the first time and redefined:

function party(){
console.log('Wow this is amazing!');
party = function(){
console.log('Been there, got the T-Shirt');

const beachParty = party; // note that the party function has not been invoked

beachParty(); // the party() function has now been redefined, even though it hasn't been called explicitly
<< 'Wow this is amazing!'

<< 'Been there, got the T-Shirt'

beachParty(); // but this function hasn't been redefined
<< 'Wow this is amazing!'

beachParty(); // no matter how many times this is called it will remain the same
<< 'Wow this is amazing!'

Losing Properties

Be careful: if any properties have previously been set on the function, these will be lost when the function redefines itself. In the previous example, we can set a music property, and see that it no longer exists after the function has been invoked and redefined:

function party() {
console.log('Wow this is amazing!');
party = function(){
console.log('Been there, got the T-Shirt');
} = 'Classical Jazz'; // set a property of the function

<< "Wow this is amazing!"; // function has now been redefined, so the property doesn't exist
<< undefined

This is called the Lazy Definition Pattern and is often used when some initialization code is required the first time it’s invoked. This means the initialization can be done the first time it’s called, then the function can be redefined to what you want it to be for every subsequent invocation.

Init-Time Branching

This technique can be used with the feature detection that we discussed in the last chapter to create functions that rewrite themselves, known as init-time branching. This enables the functions to work more effectively in the browser, and avoid checking for features every time they’re invoked.

Let’s take the example of our fictional unicorn object that’s yet to have full support in all browsers. In the last chapter, we looked at how we can use feature detection to check if this is supported. Now we can go one step further: we can define a function based on whether certain methods are supported. This means we only need to check for support the first time the function is called:

function ride(){
if (window.unicorn) {
ride = function(){
// some code that uses the brand new and sparkly unicorn methods
return 'Riding on a unicorn is the best!';
} else {
ride = function(){
// some code that uses the older pony methods
return 'Riding on a pony is still pretty good';
return ride();

After we’ve checked whether the window.unicorn object exists (by checking to see if it’s truthy), we’ve rewritten the ride() function according to the outcome. Right at the end of the function, we call it again so that the rewritten function is now invoked, and the relevant value returned. One thing to be aware of is that the function is invoked twice the first time, although it becomes more efficient each subsequent time it’s invoked. Let’s take a look at how it works:

Continue reading %JavaScript Functions That Define and Rewrite Themselves%

20 Best New Portfolio Sites, October 2017

Original Source:

Hey WDD readers, it’s October, so you know what that means: it’s time for Christmas-themed websites! No, I wouldn’t actually do that to you. But I don’t have any Halloween-themed websites either. It’s probably for the best.

What I do have is yet another almost-even mix of design trends and aesthetics. Could this be the end of bandwagon-hopping? Could we possibly be that lucky? I doubt it, but the last few months have been pure pleasure in terms of variety, and I hope this continues.


Today, we start off with Heartbeat, a web and app agency. Their site, while hearkening back to the days of pure minimalism, is loaded with personality, and some pretty ingenious animation. This is the first time in a while that animated inter-page transitions haven’t just annoyed me.

I’d also note how their contact form is dead simple and short. And if even that’s too much for a given client, they put their phone number, Skype ID, and email right where potential customers can find them. I’m sold, and I don’t even need them to make me anything.


Believe is or not, Anakin has nothing to do with a certain notable whiny villain who only stops whining when they cut his limbs off, which is presumably one of the better times to whine. It’s a design studio. It’s got that post-minimalist style, lots of white space, and elegant (if somewhat small at times) typography. Some aspects of their site (especially the labels on their contact form) could use a lot more contrast, but otherwise, this site is darned pretty.

Jony Guedj

Jony Guedj is a filmmaker, and his site makes that very, very clear. I mean, the portfolio itself is basically a minimalist “film reel”, with a timeline at the bottom that is reminiscent of video editing apps. The site might be minimalist, but it’s creative, and gets the point across fairly quickly. Plus, I’d say it’s a fantastic example of how to use a horizontally scrolling layout.

George Hastings

George Hastings’ portfolio is a simple, but finely crafted affair. The colors are striking, the type is solid, and the little animations are downright superb. It feels like minimalism had a brief fling with brutalism, and the result is a site that manages to feel utilitarian in a way, but still quite pretty. Also, you should absolutely have a look at this guy’s code and design experiments.

Elsa Muse

Elsa Muse’s work is about as artsy as you can get, and so is her site. It’s got some textbook post-minimalism [I should be writing that textbook] blended rather harshly with the boldest colors out there. The header of the home page is one of those designs that’s a bit of an eyesore on purpose. It’s supposed to stand out, rather than sooth. In a way, it’s genius. With this kind of site, you’ll only ever attract the sort of clients who love your style.

Dries Van Broeck

Dries Van Broeck is a motion designer. While the rest of his site is definitely well-crafted, you’ll be coming here for the animation most of all. So obviously, all of his work and many random site elements are animated, bouncing around, and generally pretty lively. Is it a bit distracting? Yes, but that is literally his job. I’d say this site sells his skills pretty well.

Alex Hunting Studio

Alex Hunting Studio has gone for the white-with-black-lines style of minimalism that used to be everywhere. It’s clean, it fits the textbook modern aesthetic, and presents their projects in slideshow format. They went for that “like a magazine, but online” look, and I’d say they nailed it.

Simon Ammann

Simon Ammann doesn’t take minimalism to a whole new level, but he comes pretty close. Until you actually click through to a project, it’s all about that very small amount of text. Basically, he gets to the point. And he uses white space pretty much perfectly.

Timothy Achumba

Timothy Achumba is a product designer at Facebook, and the experience shows in his work. It’s dark, it’s sleek, it’s pretty. While the UI is simple and unassuming (as portfolios go, anyway), I couldn’t find a single flaw to criticize. Okay, maybe I would have made the contact info more prominent; but this guy’s working for Facebook. He doesn’t need regular clients to hire him often. He just needs to show off his near-flawless work until he moves on to the next billion-dollar corporation.

Matthew Vernon

Matthew Vernon’s portfolio took a fairly normal business site layout and gave it a semi-retro feel with magazine-like typography, and that classic “Internet Blue”. It’s a simple change to a simple site; but it gives the whole thing a bit of a nostalgic feel, while still looking professional.

Malte Gruhl

Malte Gruhl’s website is as psychedelic as his name. That’s really the only way I can properly describe it. Oh sure, “artsy”, “post-minimalist”, “etc.”… these are all fairly accurate descriptors. But really, it’s a bit more like a chaotic art project than a website. I don’t know if it will sell his services, but it’s definitely hard to forget. I’d almost hire the guy just to see what would happen.

Tyler Hancock

After that last visual feast, Tyler Hancock’s light, minimalist, and type-driven portfolio is soothing to the eyes, even while bordering on brutalism. With big text and bigger images, this site is a delight for anyone who prefers simplicity and order in a site design.

Matt Lee

Matt Lee bills himself as a “creative developer”, and judging by his site, I’d say he earned the title. What looks to be—at first glance—a typical dark layout turns out to be quite stylish. From the typography, to the “pixel” theme (you’ll see what I mean if you look hard at the backgrounds), to the way he uses photographs to reinforce the site’s visual themes, everything is put together beautifully.


Laboratorium isn’t anything groundbreaking, but it’s a pretty, and well-made site. I do particularly like the way they handle large resolutions, though.

Ben Bate

Ben Bate’s portfolio only looks like it was made with Bootstrap. it’s actually custom made to look like Bootstrap! Okay, all jokes aside, this is an interesting one due to the sales strategy, rather than the aesthetics. Instead of depending on images or the usual copy to sell services, there’s a whole lot of social proof. You get to see the brands Ben has worked for before you even get to see examples of his work. There’s even a few classic testimonials at the bottom of the page.

Even more interesting is his sales pitch: you tell him what you want, and he’ll prepare a PDF of relevant work samples. And hey, at that point, you’re already in email contact with him, right? It’s clever, and requires no more work on the part of the client than usual.


Booreiland is a Dutch digital agency that combines a fairly familiar layout with basically all of my favorite little twists: The effective use of yellow. Drop shadows that don’t suck. Animation that, while obvious, feels understated, and wouldn’t totally break the site were it to go missing. Fantastic type. It’s all good.


I live in Mexico, and I can tell you that design sensibilities south of the border trend toward the extremely colorful. LatinMedios doesn’t go full double rainbow, but they have kept some of that color in their branding. To be fair, it’s in some of their work, too. It depends on the client.

The rest of the site is a classic nearly-monochromatic business portfolio, with background animations and all the trimmings. It’s a blend of design thinking that could only come from the collision between two or more cultures. LatinMedios is in the U.S., Mexico, and several places in South America, so that just fits.


Upperquad brings us a site that’s just plain pretty. It embraces that post-minimalist style, with soft colors, big type, and some subtle (and sometimes not-subtle) animation to spice things up. The use of seemingly randomized geometric shapes adds to the feeling of asymmetry and artful chaos; but the site itself is still simple and usable.


Xigen is another one that is just plain pretty and well-done, while not going too experimental. Give it a look!


Untold is last, but not least, with a lovely dark, elegant website that gets right to the point. Mind you, it comes with the usual drawbacks of a site that’s meant to be elegant: namely the small body text size. I don’t know when small text got classified as “modern and elegant”, but I’m going to blame the print industry, as usual. (Just kidding, I love you guys.)

550+ Watercolor Textures, Backgrounds & Elements – only $17!


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

Collective #355

Original Source:


Inspirational Website of the Week: Peter Van Alphen

An interesting navigation with lots of attention to detail. Our pick this week.

Get inspired


Our Sponsor
Project management is better when it’s visual

Dapulse is the next generation of visual tools, built specifically for designers and developers.

Check it out


CSS Grid Challenge: Winners and Templates

The winners of Smashing Magazine’s CSS Grid challenge and the great resulting templates are out.

Check it out


Vue.js Style Guide (beta)

The official style guide for Vue-specific code.

Check it out


React Static

A progressive static-site framework for React.

Check it out


Super Mario Bros in JavaScript

A great video series on how to implement Super Mario Bros in JavaScript. By Meth Meth Method.

Watch it



Use Vue components in your React app or use React components in your Vue app with this library.

Check it out



GSDevTools offers a visual UI for interacting with and debugging GSAP animations.

Check it out


UI Avatars

With UI Avatars’ simple-to-use API you can generate avatars with initials from names.

Check it out


The Intl.PluralRules API

Mathias Bynens shows how to use the new Intl.PluralRules API for pluralization.

Read it


URL to PDF Microservice

A self-hosted service for rendering receipts, invoices, or any content in PDF.

Check it out


Reduce App

A Mac app for reducing the file size of Sketch files. Made by the team behind Flawless App.

Check it out


Creating Vue.js Transitions & Animation: Live Examples

Nicolas Udy shows how to create some practical animations and transitions in Vue.js.

Read it


Web Components: The Long Game

Great read by Alex Russell on Web Components.

Read it



Pageclip lets you collect info from users without a server.

Check it out


Dropbox Design

What an evolution! The new Dropbox design is picking up on some new trends with expressive typography and vibrant colors.

Check it out


The future of accessibility for custom elements

Rob Dodson writes about how to ensure that custom elements are semantic and accessible.

Read it


Designing A Realistic Chronograph Watch In Sketch

A true master class in Sketch by Nikola Lazarević.

Read it


React, Inline Functions, and Performance

Ryan Florence’s in-depth explanation of inline functions in React.

Read it


Interactive Vim tutorial

Learn Vim interactively with this fun tutorial.

Check it out


The repo of the source code and documentation powering

Check it out


Await and Async Explained with Diagrams and Examples

Nikolay Grozev’s great visual guide to Await and Async.

Read it

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

Usability as a Design Consideration

Original Source:

Inspired Magazine
Inspired Magazine – creativity & inspiration daily

Designers understand the importance of utility Sometimes it can be difficult to explain to non-designers, such as marketing managers, why utility is more important than aesthetics.

That’s one of the biggest challenges every designer faces when designing user interfaces for software and websites, where the work is subject to approval from higher level marketing executives.

Of course it is important to try and get the best looking result that you can, but not if it means getting in the way of what the user wants to achieve when visiting your website or using software designed by you.

Usability is a dynamic field, the rules are not static

There are some old usability rules that people are clinging to that may no longer be relevant, because the majority of people are now either using wide screen monitors or mobile devices. Some users also have multiple monitors attached to a single device.

We need to think about how to create acceptable outcomes for all these different display types. If anyone feels like they’ve been left out, overlooked, or ignored, you can be certain it will generate complaints. This looks bad for you as a designer, even if neglecting to support a certain display type wasn’t your decision.

Accessibility is extremely important as well

The one thing that’s even worse than somebody feeling excluded is somebody feeling that they’ve been discriminated against.

Because accessibility is so easy to include these days, there’s really no excuse not to do it. Some managers may despair at the additional time spent catering to a “fringe group” that they don’t see any value in supporting.

When you are faced with that attitude, it’s worth pointing out that approximately 10 percent of the population has a disability. Even if the manager can’t see the value of accessibility from simply a fairness point of view, they should at least understand the economic impact of alienating up to 10 percent of the potential market.

Taking the time to do things properly will be noticed and appreciated by those who benefit from you doing so. They may even talk about it on social media, which can yield valuable PR points for the company.

Naturally the opposite is also a possibility. If you blatantly neglect accessibility and it makes the wrong person angry, their social media diatribe may well have solid repercussions for you. If a competitor is providing better accessibility than you are, they may gain some of the market share that may otherwise have gone to you.

Aim for simplicity

When it comes to GUI design, it seems many people are tempted to show off how complex they can make the design, believing people will be impressed by this. Produce something special, and initially they may really be impressed.

It becomes a problem when that initial good impression is squandered due to poor usability. The user becomes frustrated and is actually likely to be more angry than if you hadn’t created a strong first impression.

This is because your fancy visual extravaganza raised their expectations, and then you failed to deliver on the promise. A bit like the F35 Joint Strike Fighter.

Expending the maximum amount of the project time and budget on developing good usability is always the safest policy. At the heart of good usability design is simplicity.

Make everything easy for the user, and they won’t become frustrated. If they don’t become frustrated, they won’t give up on your site and look for solutions elsewhere.

Conventions exist for a reason

Everyone wants to express some creative originality, but be careful when your desire for originality begins to cross over well-established conventions. If you suddenly flip the rules, it can lead to confusion, and confusion is not a desirable outcome.

In no way does that mean you should follow the herd. Trends and fads can be risky to follow. Also it’s not sensible to follow a trend that you didn’t set. Being perceived as a follower is not a good perception.

What you do need to do is be aware of what long standing conventions exist and try to not digress too far from those. These conventions have created an expectation for users, and it’s crucial to understand that when reality does not meet expectation, the usual result is disappointment or bewilderment.

Never make your users do any kind of thinking

This is actually the logical conclusion of using conventions and keeping things simple. You do all the thinking so the user doesn’t have to.

Why is it bad if the user is forced to think? Because it slows things down and breaks immersion in whatever it is they are doing. You want the user to be fully immersed in their task, not thinking about what they’re doing. That counts double if it’s a commercial site and your aim is for the user to buy something from you.

If you’ve done a good job of creating a practical design, everything should be intuitive, with no need for any thinking to be done. Part of your job as a designer is to anticipate what the user is going to try to accomplish and do whatever you can to facilitate that accomplishment.

Common things to watch for include:

Things that look clickable but aren’t
Things that don’t look clickable but are
Confusing or poorly worded instructions
Objects overlapping on screen
Excessive delay between click and response
Improper tab order
Blocking normal operation of input devices
Expecting desktop interaction from mobile devices

Your designs are your reputation

Every design you create needs to work well, and this is more important than how the design looks. When a design works properly, it will stand out from the vast majority of designs that actually don’t work at all well.

So remember this when you are designing your next interface, because your reputation stands or falls on the quality of the usability you have incorporated into it.

This post Usability as a Design Consideration was written by Catalin Zorzini and first appearedon Inspired Magazine.

These lost type symbols need to make a comeback

Original Source:

Where would we be without punctuation marks? In a land of grammatical misunderstandings, that's where! (See, we're only three sentences into this article and punctuation is already helping to make sense of everything.) 

However there are some typographic symbols that have fallen out of fashion, and it's the mission of the Progressive Punctuation movement to bring them back.

Chances are you've sometimes wished that the forgotten symbols dusted off by Progressive Punctuation – such as the sarcasm mark – were more widely used. After all, written communication is a complex thing, and it can be easy to misinterpret what a person means simply by reading their words alone.

As Progressive Punctuation explains on its site, "nuances like sarcasm, certitude, and irony can be difficult to convey because of the gap between our expression in verbal language versus written language."

50 top typography tutorials

So what are these mysterious symbols, and how can they help us? The full list of 14 symbols on the Progressive Punctuation site covers emotions and ideas such as sarcasm, doubt, and irony.

You could argue that if a person wants to convey these feelings then they should rely on their words instead of their punctuation, but we've all probably had a straightforward text message or email completely misinterpreted at some point because they read differently to how the writer intended. Plus, they look more professional than emoji.

The sarcmark could come in handy when making jokes on the internet

On the Progressive Punctuation site you can explore the meanings behind all of these forgotten typographic symbols, as well as finding out who invented them and examples of when they should be used.

By raising awareness of these symbols, Progressive Punctuation wants to bring them back into the mainstream and get typographers to include them in their work.

The site is also interested in hearing about any symbols it has missed. So if you know about one that isn't yet on the homepage, or perhaps you've even invented your own, be sure to send Progressive Punctuation an email to let it know all about it.

Related articles:

10 typographic mistakes everyone makes (including us)100 amazing Adobe Illustrator tutorialsThe 28 best typography apps

Sliced Dual Image Layout

Original Source:

Today we’d like to share some layouts with a sliced image look with you. The idea is to show some text elements in a grid layout and change the content and images in a slideshow fashion. For the background image slices, we created a little plugin that has a couple of additonal options. For making an interesting transition, we use a glitch effect. This effect we also apply to some of the text.


This demo is kindly sponsored by: FullStory: See Every Click, Swipe, and Scroll.

Attention: We use a couple of new CSS properties, like CSS grid and clip-path which will only work in modern browsers.

Have a look at the demo screenshots:




We hope you enjoy these layouts and find them useful!

References and Credits

anime.js by Julian Garnier
Images by
imagesLoaded by Dave DeSandro
Charming.js by Yuan Qing

Sliced Dual Image Layout was written by Mary Lou and published on Codrops.