Jonnah Moreno caught our eyes and made us fall in love with his art from the first sight. The richness of colors, diversity of textures and variety of shapes all make Jonnah Moreno’s art stand out in the crowd. Let’s find out more about the designer together.
Tell us something about you (a short bio).
Hi, it’s me Jonnah Moreno, and I am Graphic Designer from a small town in Chihuahua just north of México called “Ciudad Juárez”.
I think that burrito is the most delicious thing. I love to create using many colors.
Your work is based mostly on “designing humans.” What or who inspired you to focus your work on this specific niche?
Because I am a Photographer too, and I love to shoot Portraits, so for me mixing things gives me everything. I can mix my photo, my design, and my art with color.
We love the abundance of color you use in your designs. What makes you choose bright colors over black and white designs?
Thank you! Actually, it’s funny because I do not prepare a palette of colors to create the artwork, just work in black and white, the piece is giving me the color solution. It’s weird, but I like to work under the taste of the moment.
What is your design process like?
First I choose my muse to work on, then I imagine the shapes that I want to give in it, from texture, accommodation, composition, and then I begin to give color to my artwork. Something that works for me a lot is to use pure colors and mix with them together.
How do you stay updated with what is new in the design world?
I love being in all possible networks, and following people whose work I love and inspire me.
I also really like to be surprised by new artists and designers, which I can find anywhere from Instagram to behance.
Have you worked with any major brands? Describe your experience. What have you learned from them?
Not so many, I would love to do more, but with brands that embrace what I believe.
What is your favorite piece of work and why? How did you create it?
It is a very difficult question because in each of my projects I give 100% of me, so each one represents a stage and evolution of my work.
Who are your favorite 3 designers?
Ufff…. 1. Rik Oostenbroek 2. David Milan 3. Erik Jones and PLUS 4 Rodolfo Baquier.
What is something new that you learned as a designer in your past experience (jobs & internships)?
Never stop learning, always keep the desire to see something that blows your mind, challenge yourself every day, and never stop creating things.
Do you have enough free time for your family, friends and for your (other) hobbies?
Yes, I do. I like to have balances in my life, but if I were honest, I love creating all the time so for me, being out of my work area helps me to clear up to create new things.
Do you remember about your first project? Tell us about it.
Yes, it was in 2009 for a new magazine in the city, and I had already worked on things, but not on something like that. I made interiors for the cover of a magazine, and there I started to create and fall in love with the colors.
What do you think the future of graphic-design holds?
I do not know, every year it grows, it transforms, it evolves, I do not know what to expect from it, it’s something that excites me.
What are the technologies you think will stand out in the next few months and years?
The iPad for sure, and any device like that, because life becomes more simple, and we need things that come to make it so.
What were your biggest accomplishments in graphic-design?
Every year I’m surprised by new things, and I always want it to be that way. I’ve worked on projects that I never imagined doing, and I never want to lose that.
Novice designers go through a hard time when their work is not appreciated by the clients. What do you do if your client is not satisfied with your work? What would you advice beginner designers to do in such circumstances?
1. Know how to choose your clients well, know if you are what they need.
2. Get as much information as possible from the project to have a bigger picture.
3. Discover why you do not like it, and if it really communicates.
4. It’s not bad to erase everything and start over, but make your time worth it.
How do you achieve and maintain creativity?
uuufff … creating new things in general, creating phrases, ideas, projects, jokes, solutions, these are all for my creativity in an exercise of life.
In a sense, it’s just an app for keeping documents in one place: little notes, to-do lists, basic spreadsheets, etc. I like the native macOS Notes app just fine. It’s quick and easy, it’s desktop and mobile, it syncs… but there are enough limitations that I wanted something better. Plus, I wanted something team-based and web-friendly (shared URLs!) and Notion hits those nails on the head.
Here’s a bunch of ways to use Notion as well as some scattered random notes and ideas about it.
Workspaces are your teams
The word “workspace” almost makes it seem like you could or should use them as your top-level organization structure within a team. Like different projects would use different workspaces. But I’d say: don’t do that. Workspaces are teams, even if it’s a party of you and only you.
Pricing is billed by workspace. Team members are organized by workspace. Search is scoped by workspace. Switching workspaces isn’t too difficult, but it’s not lightning fast, either. I’d say it’s worth honoring those walls and keeping workspaces to a minimum. It’s almost like Slack. It’s easy to get Too-Many-Slack’d, so best to avoid getting Too-Many-Notion’d.
Meeting notes
We have a weekly all-hands meeting at CodePen where we lay out what we’ve done and what we’re going to do. It’s nice to have that as a document so it can include links, notes, comments, embeds, etc.
Those notes don’t disappear next week — we archive them as a historical record of everything we do.
Publishing and advertising schedules
I like looking at a spreadsheet-like document to see upcoming CSS-
Tricks articles with their statuses:
But that same exact document can be viewed as a calendar as well, if that’s easier to look at:
There can be all sorts of views for the same table of content, which is a terrific feature:
Knowledge bases
This might be the easiest selling point for Notion. I’m sure a lot of companies have a whole bunch of documents that get into how the company works, including employee databases, coding guidelines, deployment procedures, dashboards to other software, etc. Sometimes that works as a wiki, but I’ve never seen a lovely setup for this kind of thing. Notion works fantastically as a collaborative knowledge base.
Public documents
I can make a document public, and even open it to public comments with the flip of a switch.
Another super fun thing in Notion is applying a header image and emoji, which gives each document a lot of personality. It’s done in a way that can’t really be screwed up and made into a gross-looking document. Here’s an example where I’ve customized the page header — and look at the public URL!
I’ve also used that for job postings:
It’s also great for things like public accessibility audits where people can be sent to a public page to see what kinds of things are being worked on with the ability to comment on items.
Quick, collaborative documents
Any document can be shared. I can create a quick document and share it with a particular person easily. That could be a private document shared only with team members, or with someone totally outside the team. Or I can make the document publicly visible to all.
I use Notion to create pages to present possibilities with potential sponsorship partners, then morph that into a document to keep track of everything we’re doing together.
We use a show calendar for ShopTalk episodes. Each show added to the calendar automatically creates a page that we use as collaborative show notes with our guests.
It’s worth noting that a Notion account is required to edit a document. So anyone that’s invited will have to register and be logged in. Plus, you’ll need to share it with the correct email address so that person can associate their account with that address.
Blog post drafts
I’ve been trying to keep all my blog post drafts in Notion. That way, they can easily be shared individually and I can browse all the collected ideas at once.
Exporting posts come out as Markdown too, and that’s great for blog post drafts because it translates nicely:
Private sub-team documents
Being able to share documents with specific people is great. For example, we have a Founder’s Meetings section on CodePen:
There are probably a million more things
Notion is simply documents with interesting blocks. Simple, but brilliant. For me, it can replace and consolidate things like Trello and other kanban tools, lightweight project management platforms, GitHub issues (if you don’t need the public-ness), wikis, Google Docs and Spreadsheets, and even simple one-off public websites.
I’d love to see Notion’s web app links open in their desktop app instead of the web. I prefer the app because I have plenty of browser tabs open as it is. It’s gotta be possible to do this with a browser extension. There used to be “Paws” for Trello and there was a browser extension that would open Trello links in that app, so there is prior precedent out there.
I’d also like Notion to explore a tabs feature. I constantly need more than one document open at a time and right now the only way to do that is with multiple windows. There is some back-and-forth arrow action that’s possible, but it would be interesting to see native tabs or native window splitting somehow.
I’d love to see some performance upgrades too. It’s not terribly bad, but working in Notion is so ubiquitous and important in my day-to-day that I’d love for it to feel more instantaneous than it currently does.
In this article, I want to show off the flexibility and real power of amCharts 4. We’re going to learn how to combine multiple charts that run together with animations that form a movie experience. Even if you’re only interested in creating a different kind of animation that has nothing to do with charts, you can still use this library, since it’s more than making charts. The core of amCharts is made to help with everything SVG: creation, layout, animation — basically a library that makes working with SVG fun!
Here’s the kind of thing I’m talking about. It’s actually a demonstration of seven different charts animated together. We’ll walk through this together, covering how it works and how to re-create it so you can have amCharts in your tool belt the next time you’re working with charts or complex animations.
There’s a lot going on in the movie. Let’s break it up into digestible parts that allow us to parse out what’s going on and re-create those parts under the hood.
The first thing we’re hit is a pie chart rising from the depths with a curved line wrapped around it. There’s nothing special about the pie chart at this point, but we’ll cover it in the next section.
But what about that curved line? Remember, we make charts, so this line is simply a XY chart with a single line on it. All the other details — grid, labels, tick marks, etc. — are hidden. So, what we’re really looking at is a stripped-down line chart!
Setting up the line and pie chart animations
amCharts calls the lines on this chart a line series. A line series has a variable called tensionX and, in this case, it’s been set to 0.75, making for a curvy line. We have to think of tension like we would a rope that is being held by two people and both ends: the tighter the rope is pulled, the greater the tension; conversely, the tension gets looser as the two ends let up. That 0.75 value is a taking a quarter of a unit away from the initial value (1), creating less tension.
// Creates the line on the chart
var lineSeries = lineChart.series.push(new am4charts.LineSeries());
lineSeries.dataFields.dateX = "date";
lineSeries.dataFields.valueY = "value";
lineSeries.sequencedInterpolation = true;
lineSeries.fillOpacity = 0.3;
lineSeries.strokeOpacity = 0;
lineSeries.tensionX = 0.75; Loosens the tension to create a curved line
lineSeries.fill = am4core.color("#222a3f");
lineSeries.fillOpacity = 1;
Initially, all the values of the series are the same: a flat line. Then, we set valueY value of the line’s animation to 80, meaning it pops up to the eights row of the chart height — that will make plenty of room for the pie when it comes in.
// Defines the animation that reveals the curved line
lineSeries.events.on("shown", function(){
setTimeout(showCurve, 2000)
});
// Sets the animation properties and the valueY so the line bounces up to
// 80 on the chart's y-axis
function showCurve() {
lineSeries.interpolationEasing = am4core.ease.elasticOut;
lineSeries.dataItems.getIndex(3).setValue("valueY", 80, 2000);
setTimeout(hideCurve, 2000);
}
// This is the initial state where the line starts at 30 on the y-axis
// before it pops up to 80
function hideCurve() {
lineSeries.interpolationEasing = am4core.ease.elasticOut;
lineSeries.dataItems.getIndex(3).setValue("valueY", 30, 2000);
setTimeout(showCurve, 2000);
}
Here is the line chart alone so we have a better visual for how that looks:
Next, the pie chart pops up from the bottom. Like a line series, amCharts includes a pie series and it has a dy property that we can set to hidden with a state of 400.
// Make the circle to show initially, meaning it will animate its properties from hidden state to default state
circle.showOnInit = true;
// Set the circle's easing and the duration of the pop up animation
circle.defaultState.transitionEasing = am4core.ease.elasticOut;
circle.defaultState.transitionDuration = 2500;
// Make it appear from bottom by setting dy of hidden state to 300;
circle.hiddenState.properties.dy = 300;
To illustrate this concept, here is a demo with that simple circle in place of a pie chart:
The idea of states in amCharts is this: you can have any number of custom states on any sprite. Then, instead of creating multiple animations with a slew of various different properties, state is changed from one to another and all the required properties that are set on the target state will animate from current values to the new state values.
Any numeric, percentage or color property of a sprite can be animated. By default, sprites have hidden and default states baked in. The hidden state is applied initially and followed by the revealed state, which is the default. There are other states, of course, like hover, active, disabled, among others, including custom states. Here is another demo showing a slice chart with innerRadius, radius and fill animating on hover:
If you look at the code in the demo, you will see some of properties of the slices are customized via pieSeries.slices.template or pieSeries.labels.template. Most of the customization, of course, can be done using themes (amCharts 4 supports using multiple themes at the same time), but since we only need to change a few properties, we can use a template. We’re using a pie chart type and all of the slices of the pie series will be created using the provided template which passes any of the inherited properties we use from the template onto our pie chart.
// Call included themes for styling and animating
am4core.useTheme(am4themes_amchartsdark);
am4core.useTheme(am4themes_animated);
// ...
// Call the Pie Chart template
var pieChart = mainContainer.createChild(am4charts.PieChart);
What if you want to set a custom color for the chart’s font? We can do this by adding a field in the data, like fontColor. That allows us to set custom colors there and then tell the label template that it should look at the field to inform the color property value.
// Define custom values that override one provided by the template
pieChart.data = [{
"name": "[bold]No[/]",
"fontColor": am4core.color("#222a3f"),
"value": 220,
"tickDisabled":true
}, {
"name": "Hm... I don't think so.",
"radius":20,
"value": 300,
"tickDisabled":false
}, {
"name": "Yes, we are using amCharts",
"value": 100,
"labelDisabled": true,
"tickDisabled":true
}];
Any property of a sprite can be customized like this. And even later, after the chart is initialized, we can change any property via the template, or if we need to access some individual object, we can get any value using something like series.slices.getIndex(3) to isolate it.
To summarize: there isn’t a single object on the chart that can’t be customized or accessed, changed, even after the chart is built. We’re working with a lot of flexibility!
The pie chart morphs into a country
I’ll be blunt: There is no way to morph a whole pie chart or some other complex object to the shape of a country. In amCharts 4, one polygon can morph into another one. And there are prebuilt methods that simply morph a polygon to a circle or to a rectangle. Here’s what we’ll do:
First, we hide all the slices of a pie chart, except one. This makes effectively transforms the remaining slice into a circle.
Then we animate the innerRadius property to 0, and the slice becomes a true circle.
There’s already a map chart at this moment, but it is hidden out of view. While it hides, we zoom into a selected country and morph it into a circle as well.
Next, we’ll show the country (which is now a circle) and hide the pie chart (which looks like the same circle at this time).
Finally, we morph the country back to its original shape.
Here is a simplified demo where we zoom in to the country, morph it to a circle, then morph it back to its default state:
Inspect that code. Note that all the methods we call, like zoomToMapObject, morphToCircle or morphBack, return an Animation object. An animation object dispatches events like animationstarted, animationprogress or animationended and we can attach listeners to them. This ensures that one animation is triggered only after another one is finished. And, if we change the duration of an animation, we won’t need to adjust timers accordingly, because events will handle it. In amCharts 4, Sprites, Components, DataItems, Animations, and other objects have an event dispatcher object which regulate any events. You can add listeners for these events and use them to make your applications super interactive.
The plane flies from one country to another
At one point, an airplane surfaces at London on a map chart and travels all the way to Silicon Valley.
It might look complex and scary, but it’s using a lot of the concepts we’ve already covered and the features come standard with the map chart included in amCharts:
MapImageSeries is created and sprites (circles and labels) are mapped to the actual longitude latitude coordinates of both cities.
// Create first image container
var imageSeries = mapChart.series.push(new am4maps.MapImageSeries());
// London properties
var city1 = imageSeries.mapImages.create();
// London's latitude/longitude
city1.latitude = 51.5074;
city1.longitude = 0.1278;
// prevent from scaling when zoomed
city1.nonScaling = true;
// New York City properties
var city2 = imageSeries.mapImages.create();
// NY latitude/longitude
city2.latitude = 40.7128;
city2.longitude = -74.0060;
// Prevent scaling when zoomed
city2.nonScaling = true;
MapLineSeries, like the standard line series we saw earlier, creates a line between the cities based on the coordinates that are provided, going from one map image to another. By default, the line is drawn so that it follows the shortest distance between the objects. That happens to be a curved line in this case. We could make it a straight line if we’d like.
// Create the map line series
var lineSeries = mapChart.series.push(new am4maps.MapLineSeries());
var mapLine = lineSeries.mapLines.create();
// Tell the line to connect the two cities (latitudes/longitudes an be used alternatively)
mapLine.imagesToConnect = [city1, city2]
// Draw the line in dashes
mapLine.line.strokeDasharray = "1,1";
mapLine.line.strokeOpacity = 0.2;
An object (plane) is added to the MapLine and it moves between the endpoints of the line by animating the plane’s position property from 0 to 1.
// Create the plane container
var planeContainer = mapLine.lineObjects.create();
planeContainer.position = 0;
// Set the SVG path of a plane for the sprite
var plane = planeContainer.createChild(am4core.Sprite);
planeContainer.nonScaling = false;
planeContainer.scale = 0.015;
// SVG plane illustration
plane.path = "M71,515.3l-33,72.5c-0.9,2.1,0.6,4.4,2.9,4.4l19.7,0c2.8,0,5.4-1,7.5-2.9l54.1-39.9c2.4-2.2,5.4-3.4,8.6-3.4 l103.9,0c1.8,0,3,1.8,2.3,3.5l-64.5,153.7c-0.7,1.6,0.5,3.3,2.2,3.3l40.5,0c2.9,0,5.7-1.3,7.5-3.6L338.4,554c3.9-5,9.9-8,16.2-8c24.2,0,85.5-0.1,109.1-0.2c21.4-0.1,41-6.3,59-17.8c4.2-2.6,7.9-6.1,11.2-9.8c2.6-2.9,3.8-5.7,3.7-8.5c0.1-2.8-1.1-5.5-3.7-8.5c-3.3-3.7-7-7.2-11.2-9.8c-18-11.5-37.6-17.7-59-17.8c-23.6-0.1-84.9-0.2-109.1-0.2c-6.4,0-12.3-2.9-16.2-8L222.6,316.6c-1.8-2.3-4.5-3.6-7.5-3.6l-40.5,0c-1.7,0-2.9,1.7-2.2,3.3L237,470c0.7,1.7-0.5,3.5-2.3,3.5l-103.9,0c-3.2,0-6.2-1.2-8.6-3.4l-54.1-39.9c-2.1-1.9-4.7-2.9-7.5-2.9l-19.7,0c-2.3,0-3.8,2.4-2.9,4.4l33,72.5C72.6,507.7,72.6,511.8,71,515.3z";
plane.fill = am4core.color("#eeeab5");
plane.horizontalCenter = "middle";
plane.verticalCenter = "middle";
Here is a demo of a plane flying from London to New York:
Notice that the plane becomes bigger when it hits the line’s halfway point? This is done with three additional lines of code we can stick at the end.
// Make the plane to be bigger in the middle of the line
planeContainer.adapter.add("scale", function(scale, target) {
return (0.07 - 0.10 * (Math.abs(0.5 - target.position))) / mapChart.zoomLevel;
})
We’re using a method that called an adapter, which is another super-powerful feature of amCharts 4. In this case, the adapter modifies the scale property (0.07 to 0.10), based on planes position (0.5).
The plane becomes big and flies away
When our plane reaches the target city (Silicon Valley in the full movie), we scale and rotate it to become horizontal and big.
At the same moment, we create another chart (the SlicedChart type) and add a PictorialSeries to it. The series share’s the same path as the plane, which creates a mask for the slices. We can use any SVG path here.
When the slices are shown, we want the plane to fly away:
This happens by animating the chart object’s dx property.
flyAway()
function flyAway(){
var animation = pictorialChart.animate({property:"dx", to:2000}, 1500, am4core.ease.quadIn).delay(2000);
animation.events.on("animationended", flyIn);
}
function flyIn(){
var animation = pictorialChart.animate({property:"dx", from:-2000, to:0}, 1500, am4core.ease.quadOut);
animation.events.on("animationended", flyAway);
}
The trail of a plane is again made with a line series, similar to the one we had in the beginning. This time, it’s a combination of two separate series: one with positive and another with negative values. When a series has the sequencedInterpolation property set to true, the animation happens with some delay for each data value and we get an effect like this:
This uses the same chart as the plane trail. We basically add another value axis to the chart and create a column series:
// Add a new axis to the chart
var valueAxis = chart.yAxes.push(new am4charts.ValueAxis());
// ... shortened for brevity
// Configure the column series
var series = chart.series.push(new am4charts.ColumnSeries())
series.dataFields.dateX = "date";
series.dataFields.valueY = "value";
series.sequencedInterpolation = true;
series.fillOpacity = 1;
series.fill = am4core.color("#222a3f");
series.stroke = am4core.color("#222a3f")
// Establish the columns at full width
series.columns.template.width = am4core.percent(100);
Then we update the background to gradient:
chart.background.fillOpacity = 0.2;
var gradient = new am4core.LinearGradient();
gradient.addColor(am4core.color("#222a3f"));
gradient.addColor(am4core.color("#0975da"));
gradient.rotation = -90;
chart.background.fill = gradient;
And finally, we zoom in on the chart to half of the total range so that we can slowly change the zoom level later to create the moving city effect.
function startZoomAnimation(){
// Animate the start and end values slowly to make it look like the city is moving
var animation = dateAxis.animate([{property:"start", from:0, to:0.5}, {property:"end", from:0.5, to:1}], 15000, am4core.ease.linear);
animation.events.on("animationended", startZoomAnimation);
}
Here is all the code, without the trail part for brevity:
am4core.useTheme(am4themes_amchartsdark);
am4core.useTheme(am4themes_animated);
// Main container
var mainContainer = am4core.create("introchart", am4core.Container);
mainContainer.width = am4core.percent(100);
mainContainer.height = am4core.percent(100);
var chart = mainContainer.createChild(am4charts.XYChart);
chart.padding(0, 0, 0, 0)
chart.zIndex = 20;
var data = [];
var date = new Date(2000, 0, 1, 0, 0, 0, 0);
for (var i = 0; i < 40; i++) {
var newDate = new Date(date.getTime());
newDate.setDate(i + 1);
var value = Math.abs(Math.round(((Math.random() * 100 - i + 10) / 10)) * 10)
data.push({ date: newDate, value: value });
}
chart.data = data;
chart.zoomOutButton.disabled = true;
chart.seriesContainer.zIndex = -1;
chart.background.fillOpacity = 0.2;
var gradient = new am4core.LinearGradient();
gradient.addColor(am4core.color("#222a3f"));
gradient.addColor(am4core.color("#0975da"));
gradient.rotation = -90;
chart.background.fill = gradient;
var dateAxis = chart.xAxes.push(new am4charts.DateAxis());
dateAxis.renderer.grid.template.location = 0;
dateAxis.renderer.ticks.template.disabled = true;
dateAxis.renderer.axisFills.template.disabled = true;
dateAxis.renderer.labels.template.disabled = true;
dateAxis.rangeChangeEasing = am4core.ease.sinIn;
dateAxis.renderer.inside = true;
dateAxis.startLocation = 0.5;
dateAxis.endLocation = 0.5;
dateAxis.renderer.baseGrid.disabled = true;
dateAxis.tooltip.disabled = true;
dateAxis.renderer.line.disabled = true;
dateAxis.renderer.grid.template.strokeOpacity = 0.07;
var valueAxis = chart.yAxes.push(new am4charts.ValueAxis());
valueAxis.tooltip.disabled = true;
valueAxis.renderer.ticks.template.disabled = true;
valueAxis.renderer.axisFills.template.disabled = true;
valueAxis.renderer.labels.template.disabled = true;
valueAxis.renderer.inside = true;
valueAxis.min = 0;
valueAxis.max = 100;
valueAxis.strictMinMax = true;
valueAxis.tooltip.disabled = true;
valueAxis.renderer.line.disabled = true;
valueAxis.renderer.baseGrid.disabled = true;
valueAxis.renderer.grid.template.strokeOpacity = 0.07;
var series = chart.series.push(new am4charts.ColumnSeries())
series.dataFields.dateX = "date";
series.dataFields.valueY = "value";
series.sequencedInterpolation = true;
series.fillOpacity = 1;
series.fill = am4core.color("#222a3f");
series.stroke = am4core.color("#222a3f")
series.columns.template.width = am4core.percent(100);
chart.events.on("ready", startZoomAnimation);
function startZoomAnimation(){
// Animate the start and end values slowly to make it look like city is moving
var animation = dateAxis.animate([{property:"start", from:0, to:0.5}, {property:"end", from:0.5, to:1}], 15000, am4core.ease.linear);
animation.events.on("animationended", startZoomAnimation);
}
The column chart appears and bends to a radar column chart
Can you guess what happens in the final scene? The initial chart (which looks like a regular column chart) is actually what’s called a radar chart with a very small arc between the chart’s startAngle (269.9°) and endAngle (270.1°) properties.
var radarChart = mainContainer.createChild(am4charts.RadarChart);
// ... Chart properties go here
radarChart.startAngle = 269.9;
radarChart.endAngle = 270.1;
The total arc angle is only 0.2° degrees and that’s why the radius of a chart becomes very big and tough tell it apart from a regular XY chart. And all we do to bend the chart is animate the start and end angles. I told you… we can literally animate everything, including angles!
radarChart.events.on("ready", bend);
function bend() {
var animation = radarChart.animate([{ property: "startAngle", to: 90 }, { property: "endAngle", to: 450 }], 3500, am4core.ease.cubicIn).delay(1000);
animation.events.on("animationended", unbend);
}
function unbend() {
var animation = radarChart.animate([{ property: "startAngle", to: 269.9 }, { property: "endAngle", to: 270.1 }], 3500, am4core.ease.cubicIn).delay(500);
animation.events.on("animationended", bend);
}
Oh, but there is one last, important thing I would like to mention: Containers. All charts and other non-chart objects in this movie are contained in a single div element. Initially, we created mainConatainer and arranged all the objects inside it. Containers support horizontal, vertical, grid and absolute layouts. Fixed or absolute positions can be used for a container’s children, and containers can be nested inside other containers. They can be aligned horizontally or vertically, set to a fixed or absolute width or height… and so on. And did I mentioned, that amCharts has built-in date, number and text formatters? Seriously, I will stop here.
As a part of the amCharts team, I often hear comments like, “but you can do all of this with d3.” Yes, you are probably right. But there are still real benefits we’re working with here — fewer lines of code, time spent writing it, and a relatively simple startup. All the animation is made up of 1,000 lines of code, so this is also a pretty lightweight resource.
But, I’m really interested in what you think. Have you tried amCharts before and have examples to show off? How about questions about getting started? Or maybe you’re not sold on the concept altogether and want to chat the pros and cons? Let’s hear it in the comments!
One of the stand-out headline features of HTML5 for many designers and developers was the addition of a number of new types of form input that could be used. For years, we’d been confined to using single-line text inputs (type="text") and laying on JavaScript and user instructions to try an accurately capture valid data of different types through that one unsophisticated field.
HTML5 brought with it new values of the type attribute that enabled us to be much more specific about the types of data we needed to capture through the field, with the promise being that the browser would then provide the interface and validation required to coerce the user into completing the field accurately.
From URLs to emails, and from search fields to dates, the hope was that instead of needing to write cumbersome JavaScript to try and validate those fields, we could just leave it to the browser to do that hard work for us. What’s more, by adding what it knows about the user’s context (type of device, type of interaction, timezones, and so on) the browser would be able to do a much better job of tailoring the interface to meet the user’s needs that we ever could as page authors.
Having new items in a spec is one thing, but it doesn’t really mean too much unless the browsers our audience are using support those features. These new values of the type attribute had the big advantage of falling back to type="text" if the browser had no support, but this may have also come at the cost of removing the browsers makers’ imperative when it came to implementing those new types in their products.
It’s the start of 2019, and HTML5 has been the current version of HTML now for more than four years. Which of those new types have been implemented, which can we use, and are there any we should be avoiding?
The type="search" input is intended to be used for search fields. Functionally, these are very the same as basic text fields, but having a dedicated type enables the browser to apply different styling. This is particularly useful if the user’s operating system has a set style for search fields, as this enables the browser to style the search fields on web pages to match.
The specification states that the difference between search and text is purely stylistic, so it may be best to avoid this if you intend to restyle the field with CSS anyway. There appears to be no semantic advantage to its use.
Can I Use input-search? Data on support for the input-search feature across the major browsers from caniuse.com.
Recommendation
Use type="search" if you intend to leave the styling of the search field up to the browser.
2. Telephone Number Fields
The type="tel" input is used for entering telephone numbers. These are like the unique usernames used by Whatsapp. If you’re unsure, ask your grandparents.
Internationally, telephone numbers take on lots of different formats, for both technical and localization reasons. Due to this, the tel input doesn’t attempt to validate the format of a phone number. You can make use of the associated validation tools such as the pattern attribute on the tag, or the setCustomValidity() JavaScript method to enforce a format if required.
On desktop browsers, the use of telephone fields seems to have little impact. On devices with virtual keyboards, however, they can be really useful. For example, on iOS, focusing input on a telephone field brings up a numeric keypad ready for keying in a number. In addition, the device’s autocomplete mechanisms kick in and suggest phone numbers that can be autofilled with a single tap.
Can I Use input-email-tel-url? Data on support for the input-email-tel-url feature across the major browsers from caniuse.com.
Recommendation
Use type="tel" for any phone number fields. It’s very useful where implemented, and comes at no cost when it’s not.
3. URL Fields
The type="url" field can be used for capturing URLs. You might use this when asking a user to input their website address for a business directory, for example. The curious thing about the URL field is that it takes only full, absolute URLs. There’s no option to be able to capture just a domain name, or just a path, for example. This does restrict its usefulness in some respects, as I imagine CMS and web app developers would have found lots of uses for a field that accepts and validates relative paths.
While this would be a valid absolute URL:
https://twitter.com/drewm
Both of these would not pass the field’s validation:
It feels like a missed opportunity that different parts of a URL cannot be specified, but that’s what we have. Browser support is across the board pretty great, with virtual keyboard devices offering some customization for URL entry. iOS customizes its keyboard with ., / and an autocomplete button for common TLDs such as .com and for my locale, .co.uk. This is a good example of the browser being able to offer more intelligent choices than we can as web developers.
Can I Use input-email-tel-url? Data on support for the input-email-tel-url feature across the major browsers from caniuse.com.
Recommendation
Use type="tel" whenever you need to collect a full, absolute URL. Browser support is great, but remember that it’s no good for individual URL components.
4. Email Fields
Possibly one of the most commonly used of the newer options is type="email" for email addresses. Much like we’ve seen with telephone numbers and URLs, devices with virtual keyboards customize the keys (to include things like @ buttons) and enable autofill from their contacts database.
Desktop browsers make use of this too, with Safari on macOS also enabling autofill for email fields, based on data in the system Contacts app.
Email addresses often seem like they follow a very simple format, but the variations actually make them quite complex. A naive attempt to validate email addresses can result in a perfectly good address being marked as invalid, so it’s great to be able to lean on the browser’s more sophisticated and well-tested validation methods to check the format.
Usefully, the multiple attribute can be added to email fields to collect a list of email addresses. In this case, each email address in the list is individually validated.
<input type="email" multiple>
Can I Use input-email-tel-url? Data on support for the input-email-tel-url feature across the major browsers from caniuse.com.
Recommendation
Use type="email" for email address fields whenever possible.
Safari on iOS shows custom keyboards for telephone, email and number fields, amongst others. (Large preview)
5. Number Fields
The type="number" field is designed for numerical values, and has some very useful attributes along with it in the shape of min, max and step. A valid value for a number field must be a floating point number between any minimum and maximum value specified by the min and max attributes.
If step is set, then a valid value is divisible by the step value.
<input type="number" min="10" max="30" step="5">
Valid input for the above field would be 10, 15, 20, 25 and 30, with any other value being rejected.
Browser support is broad, again with virtual keyboards often defaulting to a numeric input mode for keying in values.
Some desktop browsers (including Chrome, Firefox and Safari, but not Edge) add toggle buttons for nudging the values up and down by the value of step, or if no step is specified, the default step appears to be 1 in each implementation.
Can I Use input-number? Data on support for the input-number feature across the major browsers from caniuse.com.
Recommendation
Use type="number" for any floating point numbers, as it’s widely supported and can help prevent accidental input.
6. Range Fields
Less obvious in use that some of the other types, type="range" can be thought of as being an alternative for type="number" where the user doesn’t care about the exact value.
Range fields take, and will often use, the same min, max and step attributes as number fields, and browsers almost universally display this as a graphical slider. The user doesn’t necessarily get to see the exact value they’re setting.
Range fields might be useful for those sorts of questions on forms like “How likely are you to recommend this to a friend?” with “Likely” at one end and “Unlikely” at the other. The user could slide the slider to wherever they think represents their opinion, and under the hood that gets submitted as a numerical value that you can store and process.
Browser support is good, although the appearance varies between implementations.
Can I Use input-range? Data on support for the input-range feature across the major browsers from caniuse.com.
Recommendation
The uses for type="range" might be a bit niche, but support is good and the slider provides a user-friendly input method where appropriate.
7. Color Fields
The type="color" field is design for capturing RGB colors in hexadecimal notation, such as #aabbcc. The HTML specification calls this a “color well control”, with the intention that the browser should provide a user-friendly color picker of some sort.
Some browsers do provide this, notably Chrome and Firefox both providing access to the system color picker through a small color swatch.
Neither IE nor Safari provide any support here, leaving the user to figure out that they’re supposed to enter a 7-digit hex number all by themselves.
Color fields might find use in theming for personalization and in CMS use, but unless the users are sufficiently technical to deal with hex color codes, it may be better not to rely on the browser providing a nice UI for these.
Can I Use input-color? Data on support for the input-color feature across the major browsers from caniuse.com.
Recommendation
Unless you know your users will be happy to fall back to entering hexadecimal color codes, it’s best not to rely on browsers supporting type="color".
Range, color and date fields as displayed by Edge, Firefox and Chrome. (Large preview)
8. Date Fields
HTML5 introduced a number of different type values for creating inputs for dates and times. These included date, time, datetime-local, month and week.
At first glance, these appear to be heaven-sent, as collecting dates in a form is a difficult experience for both developer and user, and they’re needed pretty frequently.
The promise here is that the new field types enable the browser to provide a standardized, accessible and consistent user interface to capture dates and times from the user with ease. This is really important, as date and time formats vary world-over based on both language and locale, and so a friendly browser interface that translates an easy-to-use date selection into an unambiguous technical date format really does sound like the ideal solution.
As such, valid input for type="date" field is an unambiguous year-month-day value such as 2019-01-16. Developers like these, as they map pretty much to the ISO 8601 date format, which is used in most technical contexts. Unfortunately, few regular human beings use this date format and aren’t likely to reach for it when asked to provide a date in a single empty text field.
And, of course, a single empty text field is what the user is presented with if their browser does not provide a user interface for picking dates. In those cases, it then becomes very difficult for a user to enter a valid date value unless they happen to be familiar with the format required or the input is annotated with clear instructions.
Many browsers do provide a good user interface for picking dates, however. Firefox has a really excellent date picker, and Chrome and Edge also have pretty good interfaces. However, there’s no support in poor old IE and none in Safari, which could be an issue.
Can I Use input-datetime? Data on support for the input-datetime feature across the major browsers from caniuse.com.
Recommendation
While convenient where it works, the failure mode of type="date" and its associated date and time types is very poor. This makes it a risky choice that could leave users struggling to meet validation criteria.
Conclusion
A lot has changed in the browser landscape in the four years since the HTML5 specification became a recommendation. Support for the newer types of input is fairly strong — particularly in mobile devices with virtual keyboards such as tablets and phones. In most cases, these inputs are safe to use and provide some extra utility to the user.
There are a couple of notable exceptions, the worst of which being the date and time fields, which not only lack utility, but also have more patchy browsers support. When support isn’t available, the fallback mode of these fields is poor. In these cases, it might be best to stick to JavaScript-based solutions for progressively enhancing the basic type="text" input fields.
If you’d like to read more, I’d thoroughly recommend the MDN web docs on these field types, and as ever, the W3C specification.
The purpose of almost every web design is to entice customers into buying your products, or subscribing to your services. However, your website can’t accomplish that goal without providing a superior user experience, which is largely defined by a great user flow.
User flow refers to a series of steps that will help your prospects interact with your website without any distractions or hindrances. Thus, it improves your conversion funnel and reduces the bounce rate. The better the user flow is, the higher the sales conversions will be.
However, designing a great user flow is easier said than done. It is a complicated process that involves creating and evaluating different stages. However, if you keep a few things in mind, you can enable a superior user flow quickly.
1. Know Thy Customers
When you build a user flow, the first thing you should think about is your customers. In-depth understanding of the target audience is fundamental to creating a well-defined user flow. If you know what solutions they expect from you, designing a suitable user flow is a lot easier. It will allow you to design a perspective similar to your users, resulting in higher conversions. This is why you need to create user personas as well as map out customer journey of your prospects.
Creating Buyer Personas
You can think of user personas as a set of characteristics that define the majority of your potential users. These are not fictional guesses. Naturally, creating buyer personas involves a lot of qualitative and quantitative research. You need to study and recognize behavior patterns, goals, skills, attitudes, and background information about your customers.
Collect as much information about your users as possible
Collect as much information about your users as possible. Make sure your user persona focuses on the present. You must know how the users are interacting with your product right now, and not speculate on how they will do so in the future.
You should also tie every characteristic of your buyer persona to real data. You can create more than one persona. In such a case, however, you will need to prioritize them as the primary (most relevant) and secondary personas. You will also need to design different user flows for each persona.
Mapping User Journeys
The next critical aspect of knowing your customers is mapping their journey. A user journey is a timeline of user actions that will show you different touch points between the customers and your website. It allows you to understand how users interact with your site and what you can do to improve this engagement. For example, you may be able to find that removing or realigning a particular stage from the journey can improve your conversions.
It usually consists of personas, timelines, touch points, and engagement channels. Detailed customer personas will allow you to identify the trigger points or problems of your consumers. The timeline determines how long the journey will take, while touch points are the stages where users will interact or take specific actions such as registering for your email list.
Engagement channels are nothing but various ways to interact with your customers such as sending promotional emails, text messaging or online chatting. However, a customer journey map will largely depend on your market niche and customer personas.
Identify the Entry Points
In addition to the user personas and buyer journey, you also need to know the various entry points. Entry points are the way your potential customers reach your website. Usually, they will get to your site through one of the following entry points.
Directly typing the web address of your site.
Through social media sites such as Facebook and Instagram. They will click on the links provided in your promotional content to reach your site.
Through organic search (or pay-per-click ads if you are running a PPC campaign) by typing the search queries in search engines such as Google or Bing.
Through advertisements and referrals on other websites, online forums, and blogging sites.
Via email links sent in your promotional emails or monthly newsletters.
Knowing these entry points is crucial because they will affect your user flow. For example, a user coming to your site by clicking a link in a promotional email is likely to be a recurring customer. This user is more interested in availing a specific offer mentioned in the email rather than exploring your site.
On the other hand, someone coming through organic search or social media promotion is more likely to be a first-time visitor. So, they will browse your site for a while and try to find out more about your business before taking any action. They will have a longer user flow with several micro-interactions compared to a returning customer.
2. Avoid Overwhelming Users with Too Much Content
In their attempt to engage users, UX designers often end up creating user flows that are overflowing with content. Unfortunately, this creates the opposite effect. Overwhelming content or features are more likely to distract or frustrate users, resulting in increased bounce rate.
Scrape off Excess Content
Whether it is excessive content or UI elements, you need to minimize as many visual distractions as possible. They are not only unnecessary, but also unattractive. So, make sure to remove all the excessive content, graphics, animations, flashy text, and flickering logos. In other words, you need to embrace simplicity.
If possible, go for a minimalist design. Most static and service-oriented websites can use a minimalist approach to design simple, yet remarkably attractive user flows for their websites. Create site layouts with only the essential elements. Use a balanced mix of images, text and other features that compliment your user flow.
Shorten the Number of Features and Options
A minimalist design also works for various features or options on your website. You need to minimize the features or choices on your site. Too many choices can lead to decision paralysis. Always make sure to provide clear-cut choices that will lead to a specific action.
The easiest way to make that happen is to create the right Calls-To-Action (CTAs) and place them suitably on your site. For example, if the primary goal is to increase your email list, your CTA should focus on asking your prospects to share their email ID with you. You can tempt them with a discount coupon for their next purchase or entice them with a monthly newsletter.
3. Create and Test Your Prototypes
Once you have a firm outline for the user flow, it is time to create different prototypes and test them. A prototype is the tangible variant of your site’s user flow. It will allow you to troubleshoot potential issues before the actual design is built, saving time and money.
Test Your Prototype with Real Users
It is always better to test your user flow prototype with real users. You can use a small group of your target audience (that matches your buyer persona) for testing. Create as many prototypes as you need. Ask this group to check out your prototype and find out what actions they take. Encourage them to provide honest feedback.
It is always better to test your user flow prototype with real users
Once you have their feedback, try to address the bottlenecks and areas of frustration using A/B testing. You can provide more than one alternative to fix a specific issue. A/B testing will help you choose the best possible solution with certainty.
Of course, getting real customers involved in prototype testing is expensive. However, consider this as an investment in building a website with high sales conversions. Alternatively, you can also hire a UX expert to find out potential issues with your existing user flow. It will be less expensive, but may not be as comprehensive as testing with real customers.
Keep Optimizing
Creating a user flow is an ongoing process. Consumers will use new entry points, your competitors will incorporate better user flow elements, and the web will also keep evolving. You will also need to keep optimizing your user flow regularly to stay relevant to these changes.
You can ask your user the following questions:
What do they love about your site? Is there something unique that encourages them to keep coming back?
Which is the most attractive feature of your site and why?
Which part of the site do they find unattractive?
What else would they recommend your website should have?
Finally, how will they rate their user experience (or shopping experience)?
Take this feedback into account when updating your user flow. For example, you can try to change the unattractive elements on your site based on the customer feedback and see if the changes can improve your sales.
Parting Words
User flow and user experience are closely interlinked. If you improve user flow, user experience is also elevated. But, before you set out to design the user flow, make sure to go through these three points. They will help you to prepare for a major user flow overhaul of your website. Once you know what needs to be built, nothing can stop you from attracting your prospects.
If you think that the WP Bakery is a new product while the Visual Composer Website Builder is just the new name behind which is the old Visual Composer – unfortunately, you are wrong.
We admit that the whole thing is quite confusing and we understand why so many of our users, as well as long-term partners, are upset with us.
Which brings us to the reason we decided to publish this post in the first place. Above all, we want to apologize for the confusion around Visual Composer, and we want to explain the whole story of what happened here.
We are sorry for the mess we have created around Visual Composer.
We admit that we should have explained what caused this situation at the very beginning before it escalated.
So let’s finally do that and dive deeper into the mind-twisting story behind this huge mess that got even worse as we tried to fix it along the way.
It all started with one thing that caused a big domino effect of issues that went down one after another:
Changing the name of the Visual Composer Page Builder
On every major WP theme, you have probably noticed the name above. After all, it was included as a premium plugin in the majority of the all-time favorite WordPress themes.
So the big question is: Why would we change the name in the first place when it was so well-known and easily recognizable?
The truth is – because we had to; we did not have a choice.
If you want the whole story, check out the video below.
It all began with our new product, the Visual Composer Website Builder. It is worth mentioning that the Visual Composer Page Builder and the Visual Composer Website builder are two entirely different products used for different purposes.
The Page Builder is an Envato-exclusive product with a lifetime license (like all products sold with Envato). The Website Builder, on the other hand, was meant to move away from the lifetime license model. We wanted to create a product much more complex in features and specially designed for the users whose building needs have rapidly evolved.
However, the new features came hand in hand with much higher development costs which that could only be sustained with a yearly license model. In addition to that, we wanted to be in the direct touch with our users because we recognized the need for the best support we could possibly provide.
However, our plans took a wrong direction because
We overlooked a crucial detail that forced us into a difficult decision
And that detail in question was the contract we signed with Envato and all its limitations.
Long story short, we were not allowed to sell another product under the Visual Composer name outside their platform.
At that point, we had to choose our next step. We had two options:
We could adjust our new product to fit the lifetime license model and put it up on Envato.
We could change the product name to lift the contractual limitations.
It was not an easy choice to make, and we knew that both options had significant downsides. We weighed our two options over and over again, and eventually, we decided to go with the option 2. We decided not to compromise the quality of our new product, and this was the only way to do it.
And that is how the Visual Composer Page Builder became WP Bakery
And that is where the whole confusion started. Not only were we buried in the developing process of our new product which required our full attention, but we also had to deal with a whole new set of unplanned changes.
Dealing with all that work, we did not immediately notice the vast confusion we created.
Not only were people confused about the name change, but they also didn’t understand what our new product, Visual Composer Website Builder, was. Was it a new product or just a rebranding of the old one? And what about WP Bakery?
So let’s take it step by step and explain the difference between the two once and for all.
What is Visual Composer Website Builder and what does it do?
The Visual Composer Website Builder is a live-preview editor with drag-and-drop features. It is not the same thing as the Visual Composer Page Builder. It is an entirely new tool. It comes in two versions; the free and the Premium version.
There are hundreds of ready-to-use content elements to choose from that will help you turn your ideas and visions into reality. It is easy to use thanks to the drag-and-drop features, and you can see all the changes instantly.
It can be used with any theme, including your existing themes. On top of that, you can choose from a variety of WP templates for different types of pages (landing pages, portfolios, corporate websites, product pages and many more).
Page editing works in two ways; frontend editor and tree view. With the tree view, you can navigate through the elements available on the page which will save you a lot of time during the process.
One big perk of the Visual Composer Website Builder is the fact that there is a header, footer, and sidebar editor available in the Premium version of the product.
In addition to that, you can access numerous useful add-ons that you can get from the third-party developers or the Visual Composer’s dedicated Hub.
Are Visual Composer Website Builder and WP Bakery the same thing?
Short answer: No. These are two entirely different tools. Let’s take a moment to explain the main differences between the two.
Some people believe that the Visual Composer Website Builder is merely a premium version of the WP Bakery. It is not.
Visual Composer Website Builder’s code was built from zero with React.Js. It does not use any of the WordPress shortcodes. It was developed using the feedback from our users to offer them the best experience possible.
However, the most significant difference between the two products is that WP Bakery is only for the content part, while Visual Composer Website Builder allows you to build a complete website (with Headers and Footers).
Like mentioned before, Visual Composer Website Builder does not use any shortcodes, while WP Bakery is shortcode-based.
In practice, this means that the VC Website Builder:
allows you to generate clean code
doesn’t get messy if you disable the plugin (like it happens with shortcode-based plugins)
On top of that, VC Website Builder comes with a cloud-based Hub from which you can download all the elements you find useful. Basically, you can handpick the elements you need and download only them rather than bloating the website with a bunch of unnecessary assets.
There’s a full list of difference between the two products that you can check right here.
That being said, we also have to point out that WP Bakery is still getting the same amount of work and attention as it did before we developed VC Website Builder. Both of the products are equally as important to us, and we want to offer the best user experience possible.
Thank you for taking a moment to go through this story with us. If you have any additional questions regarding our products, please leave a comment, and we will try to give you the answer as soon as possible
The difference between a CSS good experience and a long frustrating one is oftentimes a matter of a few small details. CSS is indeed nuanced. One of the most common areas where I see struggles is layout. Personally, I like to study patterns. I notice that I tend to use a small group of patterns to solve the majority of my layout problems. This article is about those CSS patterns I use to get myself through layout challenges. It is also about approaching situations agnostically, regardless of the CSS methodologies used, whether that’s SMACSS, BEM, or even the hot topic of CSS-in-JS because they all focus on the properties themselves rather than architecture, organization, or strategy.
Just for fun, let’s start with a test
We’ll use a platform that I happen to have made called Questionable.io and I’ve used it to create a test that we’ll get to below. Don’t worry, there is no personal data collected, results are anonymous and it’s totally free.
The purpose of the test is to see if you can recognize specific CSS behaviors and problems in context without first being presented with the material. I didn’t set out to make the test difficult, but CSS layout nuances tend to be somewhat complex, especially without having a lot of exposure to them. Remember, this all for fun. The results are not an indication of your awesomeness, but hopefully you get value out of it.
The test is 10 questions and should 10 minutes or less.
Interested in the test but don’t want to take it? Here’s a link to the questions with their correct answers.
Done already? Great! Let’s go over the questions one-by-one to get a better understanding of the layout patterns that are covered in the test.
Question 1: Box Model
Learning the Box Model should be high priority on anyone’s list. While this CSS-Tricks Box Model Article may be a bit old, don’t underestimate its value and relevance to modern CSS. The Box Model is prerequisite knowledge for almost every CSS topic related to layout.
This particular question is testing how to get the Box Model’s computed width. The box clearly has width: 100px; but it turns out that the default rules of the Box Model apply width properties to the content layer of the box. The computed width (how wide is rendered on the page) is the sum of the content layer, padding layer, and border layer. For this reason, the answer is 112px:
.box {
width: 100px; /* Take this */
height: 50px;
padding: 5px; /* Plus this x2 for left and right */
border: 1px solid red; /* Plus this x2 for left and right */
background-color: red;
/* = 112px of computed width */
}
If you’ve encountered a situation where the last column or tab in a UI wraps down to the next line and you were confident that five tabs (all set to width: 20%;) adds up to 100%, then it’s very possible that this was the issue. Five tabs at 20% width does add up to 100%, but if there’s padding and/or borders involved, those will add width there won’t be room for the last tab to fit on the same line.
Around the time of CSS3 being introduced, a new tool called box-sizing came to CSS. This allows us to change what layer of the Box Model we want width to apply. For example, we can do box-sizing: border-box; which means we want any width rules to apply to the outside of the border layer instead of the content layer. In this test question, if box-sizing: border-box; had been applied, the computed width would have been 100px.
This is old news for some of you but a good reminder for pros and novices alike.
The second test question could almost be considered “Part Two” of the first question. Remember, it’s one thing to read, “The Box Model has layers and they all contribute to the calculated width and hight.” It’s another to be able to recognize a Box Model problem in a real situation. This particular problem is somewhat of a classic among those who have been doing CSS for a while. It stems from the fact that borders take up space and will push things around since they are a part of the Box Model. Introducing borders during a state-transition, like :hover, will mean that boxes get bigger and thus push subsequent boxes down. It can also create a jittery experience:
Out of all the possible solutions in the test question, doing border: 2px solid transparent on the initial “un-hovered” state would be the only one that fixes the problem. box-sizing doesn’t fix this problem because we are not explicitly setting a height. If we had, then the border would be factored on the inside of the height and there would be no shift — but this wasn’t the case.
There are also other solutions that weren’t mentioned as possible answers. One is faux borders with box-shadow and the other is to use outline instead of border. Either of those would have resulting in no shifting during state changes because they are not layers in the Box Model. Here’s another CSS-Tricks article to read more about these solutions
Keep in mind that outline does not support border-radius.
Question 3: Absolute position vs. fixed position
Aside from knowing when to use each and how they differ in visual behavior, it’s also very important to know the rules for how each positioning method attaches to a parent element with its top, right, bottom, or left properties.
First, let’s review Containing Block. The short definition is that a Containing Block is most often the parent of any given element. However, the rules for Containing Block are different between absolute and fixed elements:
1. For absolute elements: The Containing Block is the nearest ancestor parent that is not static. For example, when an element is absolute-positioned, and contains top, right, bottom, or left properties, it will position relative to any parent that has a position of absolute, relative, fixed, or sticky.
2. For fixed elements: The Containing Block is the viewport, regardless of any parents that have position values other than static. Also, the scrolling behavior is different than absolute in that position: fixed; elements stay “fixed” to the viewport as it scrolls, hence the name.
Many developers believe absolute-positioned elements only seek the nearest position: relative; parent. This is a common misconception simply because position: relative is most often paired with position: absolute; to make a Containing Block. The reason it’s commonly used is because relative keeps the parent in flow which is often the desirable behavior. There are times though that the Containing Block of an absolute positioned element is also absolute positioned. This is totally okay depending on the situation. If all parents are static, then the absolute positioned element will attach to the viewport — but in a way that scrolls with the viewport:
There is a lesser-known caveat to the two rules above: Anytime a parent has a transform property (among a few others) with a value other than none, then that parent will become the Containing Block for absolute- and fixed-positioned elements. This can be observed in this Pen where the notice is position: fixed; and the parent has transform but only when hovered:
Question 4: Parent and first/last child collapsing margins
This is one of those CSS details that can really bite you if you don’t know how it works. There is a CSS concept called Collapsing Margins and many people are familiar with the form of it called Adjacent Siblings Collapsing Margins. However, there is another form of it called Parent and First/Last Child Collapsing Margins which is lesser known. Here is a demo of both:
Each paragraph tag has a top and bottom margin of 1em that are provided by the browser. So far, that’s the easy part. But why is the gap between the paragraphs not 2em (the sum of the top and bottom)? This is called Adjacent Sibling Collapsing Margins. The margins overlap such that the larger of the two margins will be the total gap size, thus the gap in this case is 1em.
There’s something else happening that’s a little strange though. Did you notice that the top margin of the first paragraph doesn’t create a gap between it and the blue container div? Instead of a gap, it’s almost like it “contributes” the margin to the parent div as if the div had the top margin. This is called Parent and First/Last Child Collapsing Margins. This form of Collapsing Margins will not happen in some circumstances if the parent has any of these:
Top/Bottom padding of any value bigger than 0.
Top/Bottom border of any width bigger than 0.
Block Formatting Context, which can be created by things like overflow: hidden; and overflow: auto;).
When I have the pleasure of explaining this small CSS detail to people and solving it with padding or border, the response is almost always, “what about padding or border of 0?” Well, that doesn’t work because the value must be a positive integer.
In the previous example, just 1px of padding allows us to toggle between using and preventing Parent/Child Collapsing Margins. The gap that shows up between the first/last paragraphs and the parent is the 1px of padding but now the margin is being factored to the inside of the container since the padding layer creates a barrier preventing collapsing margins.
Regarding the question, I’m confident you can see what the problem is in this UI:
The first .comment (without the .moderator class) is experiencing Collapsing Margins. Even without looking at the code, we can see that the moderator comment has a border and the non-moderator one does not. In the question, there were actually three answers that were considered correct. Each one is actually already applied in the source of the Pen, they’re just commented out.
One reason why this form of Collapsing Margins isn’t as widely known as the others is the wide array of ways we can “accidentally” avoid it. Flexbox and grid items create a Block Formatting Context, so we don’t see this form of Collapsing Margins there. If our “comments” UI were a real project, chances are we would have had padding on all four coordinates to create spacing all the way around, which would fix any Collapsing Margins for us. As rare as it might be, I wouldn’t want you to spend a whole day scratching you head on this one, so it’s good to keep in your thoughts when working with layout.
Here are some CSS-Tricks articles on this subject:
When it comes to using percentage units, the percent is said to be based on the Containing Block’s width or height (usually related to the parent). As we stated earlier, an element with transform will become a Containing Block, so when an element is using transform, the percentage units (for transform only) are based on its own size rather than the parent.
In this example, we can see that 50% means two different things depending on context. The first red block has margin-left: 50%; and the second red block is using transform: translateX(50%);:
The hangover stems from the fact that we are using width: 100%; on the footer and also adding padding. The container is 500px wide which means the footer’s content layer (being 100%) is 500px wide before padding is applied to the outside of that layer.
The hangover can be fixed with one of these two common techniques:
Use box-sizing on the footer directly or via a reset, lie we discussed earlier.
Remove the width and do left: 0; right: 0; instead. This is a great use case for doing a left value and a right value at the same time. Doing so will avoid Box Model issues because the width will use its default value auto to take up any available space between paddings and borders when left: 0; right: 0; are set.
One of the options was “Remove the padding on the footer.” This would technically work to fix the hangover because the content layer being 100% would have no padding or border to expand it beyond the width of the container. But I think this solution is the wrong approach because we shouldn’t have to change our UI to accommodate Box Model issues that are easily avoided.
The reality for me is that I always have box-sizing: content-box; as apart of my reset. If you also do this, then perhaps you don’t see this problem often. But I still like to do the left: 0; right: 0; trick anyways because, over time, it has been more stable (at least in my experience) than having to deal with Box Model issues arising from width: 100%; on positioned elements.
Question 7: Centering absolute and fixed elements
Now we’re really starting to combine all the material from above with the centering of absolute and fixed elements:
Since we’ve already covered most of the material in this test question, I’ll simply point out that horizontal and vertical centering can be done “the old school way” with negative margins or the newer “kinda old school but still good” way of doing transforms. Here is an amazing CSS-Tricks guide on all things centering.
It used to be said that if we know the width and height of the box, the we should use negative margins because they’re more stable than transitions, which were new to browsers. Now that transitions are stable, I use them almost all the time for this, unless I need to avoid a Containing Block.
Also know that we can’t use any margin: auto; tricks for this because we need modals to “hover” over the content which is why position is typically used to them out of Normal Flow.
Speaking of which, let’s move on to the next question, which deals with centering with Normal Flow.
Question 8: Centering elements with Normal Flow
Flexbox brought us many amazing tools for solving difficult layout problems. Before it’s release, it was said that vertical centering was one of the most difficult things to do in CSS. Now it’s somewhat trivial:
Notice that with flexbox items, the margin: auto is being applied to top, right, bottom, and left to center vertically and horizontally. Doing vertical centering with auto didn’t work in the past with block-level elements which is why doing margin: 0 auto is common.
Question 9: Calculate mixed units
Using calc() is perfect when two units that we can’t add up on our own need to be mixed or when we need to make fractions easier to read. This test question asks us to figure out what calc(100% + 1em) would be based on the fact that the width of the div is 100px. The correct answer is that the calculated value is 100px plus whatever 1em is in the browser. We don’t know what 1em will be when we write our CSS because it’s context-dependent — thus the reason why calc() is needed in the first place.
There are a few key places where I see myself regularly reaching for calc(). One is anytime I want to offset something by 100% but also add a fixed amount of extra space. Dropdown menus can be a good example of this:
The trick here is that we want to make a “dropdown system” where the dropdown menu can be used with different trigger sizes (in this case, two different size buttons). We don’t know what the height of the trigger will be but we do know that top: 100%; will placed at the top of our menu and at the very bottom of the trigger. If every menu needs to be at the bottom of their respective trigger, plus .5em, then that can happen with top: calc(100% + 0.5em);. Sure, we could use top: 110%; as well, but that extra 10% would be context-dependent based on the height of the trigger and the container.
Question 10: Negative margins
Unlike positive margins that push away from their siblings, negative margins pull them closer together without moving the sibling elements. This final test question offers two solutions that technically work to eliminate the double border in our button group, but I strongly prefer the negative margins technique because removing borders would make it much more challenging to do certain tricks like this hover effect:
The effect is a “common border” that is shown between the buttons. Buttons can’t actually share a common border so we need this negative margin trick to make the two borders overlap. Then I’m using a z-index to manage which border I want to be on top depending on the hover state. Note that z-index is useful here even without absolute positioning, but I did have to do position: relative. If I had used the technique to remove the left border of the second button, this effect would have been more difficult to pull off.
It all adds up!
There is one last demo I want to show you that utilizes many tricks we’ve discussed so far. The task is to create UI tiles that expand all the way to the left and right edges of the container with gutters. By tiles, I mean the ability to have a list of blocks that wraps down to the next line when there’s no more space. Hover over the tiles to see the full effect:
The hurdle with this task is the gutters. Without gutters, it would be trivial to get the tiles to touch the left and right edge of the container. The problem is that the gutters will be created by margin, and when we add margin to all sides of the tile, we create two problems:
Having three tiles with width: 33.33%; in combination with margin will mean three tiles cannot fit on one row. While box-sizing will allow us to have padding and borders on the .tile which will be contained within 33.33%, it will not help us with margins — that means the computed width of the three tiles will be more than 100%, forcing the last one down to the next line.
Tiles on the far left and right side will no longer touch the edges of the container.
The first problem can be solved with calc((100% / 3) - 1em). That’s 33.33% minus the left and right margins of each tile. Adjacent Sibling Collapsing Margins don’t apply here because there is no such thing as Collapsing Margins when it comes to left and right margin. As a result, the horizontal distance between each tile is the sum of the two margins (1em). It also doesn’t apply in this case with the top and bottom margins because the first tile and the fourth tile are technically not Adjacent Siblings, even though they happen to be right next to each other visually.
With the calc() trick, three tiles are able to fit on a row, but they still don’t extend to edges of the container. For that, we can use negative margins in the amount equal to the left and right margin of each tile. The green dotted line in the example is the container where we will apply negative margins to draw out the tiles to match the edge of the surrounding content. We can see that how it extends into its parent’s padding area (the main element). That’s okay because negative margins don’t push neighboring elements around.
The end result is that the tiles have nice gutters that extend edge-to-edge so that they align to the neighboring paragraph tags outside the tiles.
There’s a lot of ways to solve tiles (and they usually come with their own pros and cons). For example, there’s a rather elegant solution using CSS Grid discussed by Heydon Pickering which is responsive using a technique that mimics container queries (but with Grid magic). Ultimately, his Grid solution to tiles is much nicer than the flexbox solution I presented, but it also has less browser support. Nonetheless, the flexbox solution is still a great way to demo all the tricks from this article at the same time.
You may already be familiar with Heydon’s work. He’s known for creating clever tricks like the Lobotomized Owl selector. If you’re not familiar, it’s certainly worth knowing and I have a video where I talk about it.
Summary
I stated at the start that I tend to look for patterns when solving problems. This article isn’t necessarily about the exact demo scenarios from above; it’s more about a set of tools that can be used to solve these and many other layout problems that we are all likely to come across. I hope these tools take you far and I look forward to hearing your contributions in the comments.
By the way, there are a number of excellent resources that cover the Box Model in thorough detail, most notably ones by Rachel Andrews and Jen Simmons that are certainly worth checking out. Rachel even has a newsletter completely dedicated to layout.
Box Alignment Cheatsheet – Great resource with visuals that highlight the various properties that affect how elements are aligned, either by themselves or relative to other elements.
Jen Simmons Labs – A slew of helpful posts, demos and experiments using modern layout methods.
I’m not so protective of CSS that I’m above hearing it criticized, but I’m certainly in agreement here. CSS does not suck. I love how the post is framed to hype up current CSS features the way features of other languages and tools are hyped:
Imagine if a tech dude walked on stage at a conference and said the following:
“This declarative language will gracefully continue on failure, allow you to write global and scoped code, and it will work across your entire front-end stack, whether it’s rendered by a framework, a CMS or a static HTML file”
… Now, if I make a slight amendment to that, the reception would probably be the exact opposite.
“CSS will gracefully continue on failure, allow you to write global and scoped code, and it will work across your entire front-end stack, whether it’s rendered by a framework, a CMS or a static HTML file”
A rather full-throated argument (or rather, response to arguments against) utility (atomic) CSS from Sarah Dayan. I wondered recently if redesigns were potentially a weakness of these types of systems (an awful lot of tearing down classes) which Sarah acknowledges and recommends more abstraction to help.
I also wonder about workflow. I sort of demand working in an environment which offers style injection, so working with CSS feels smooth. I also worry that having to change HTML every time I want to modify a design requires refreshing. I guess if you are in a hot module reloading situation, then it’s fine.
Also this seems like it can just go too far. At some point, altering a space-separated string to do everything you wanna do has ergonomic limitations.
You may not think about it often, but the Internet uses a colossal amount of electricity. This electricity needs to be produced somewhere. In most countries, this means the burning of fossil fuels. This, in turn, means that the Internet’s carbon footprint has grown to the point where it may have eclipsed global air travel, and this makes the Internet the largest coal-fired machine on Earth.
The Mozilla Internet Health Report 2018 states that — especially as the Internet expands into new territory — “sustainability should be a bigger priority.” But as it stands, websites are growing ever more obese, which means that the energy demand of the Internet is continuing to grow exponentially.
All the while, the impacts of climate change grow worse and more numerous with each passing year. The vast majority of climate scientists attribute the increasing ferocity and frequency of extreme weather events around the world to climate change, which they largely attribute to human activity. While some question the science, even the world’s largest oil companies now accept it, and concede that their business models need to change.
Every country on Earth (with the exception of the US), is signed up to the Paris Climate Agreement. Although the US controversially pulled out, many of America’s most influential individuals, cities, states, and companies — representing more than half the US population and economy — have retained their commitment to the agreement by way of the America’s Pledge initiative.
As web developers, it’s understandable to feel that this is not an issue over which we have any influence, but this isn’t true. Many efforts are afoot to improve the situation on the web. The Green Web Foundation maintains an ever-growing database of web hosts who are either wholly powered by renewable energy or are at least committed to being carbon neutral. In 2013, A List Apart published Sustainable Web Design by James Christie. For the last three years, the SustainableUX conference has seen experts in web sustainability sharing their knowledge across an array of web-based disciplines.
So, apart from powering servers with renewable energy, what else can web developers do about climate change?
“You Can’t Manage What You Can’t Measure”
Perhaps the biggest win when it comes to making websites more sustainable is that performance, user experience and sustainability are all neatly intertwined. The key metric for measuring the sustainability of a digital product is its energy usage. This includes the work done by the server, the client and the intermediary communications networks that transmit data between the two.
With that in mind, perhaps the first thing to consider is how do we measure the energy usage of our website? This is actually a trickier undertaking than you might imagine, and it’s difficult to get precise data here. There are, however, some good fallbacks which we can use that demonstrate energy usage. These include data transfer (i.e. how much data does the browser have to download to display your website) and resource usage of the hardware serving and receiving the website. An obvious metric here is CPU usage, but memory usage and other forms of data storage also play their part.
Data transfer is one thing that we can measure quite easily. All of the major browsers provide developer tools that allow us to measure network activity. In this screenshot below, for example, we can see that loading the Smashing Magazine website for the first time incurs just under a megabyte of data transfer. Firefox’s developer tools actually provide us with two numbers: the first is the uncompressed size of the files that have been transferred, and the latter is the compressed size.
The most common tool for compressing assets as they travel across the network is gzip, so the difference between those two numbers is typically a result of gzip’s work. This latter number represents how much data has actually been transmitted and is the one to keep an eye on.
Note: There are plenty of other tools that provide us with a metric for data transfer including the much revered WebPagetest.
For measuring CPU usage, Chrome provides us with a granular Task Manager that shows the memory footprint, CPU usage and network activity of individual tabs. For the more adventurous/technical, the top (table of processes) command provides similar metrics on most Unix-like operating systems such as macOS and Ubuntu. Generally speaking, we can also run the top command on any server to which we have shell access.
Fortunately, there are efforts such as WebsiteCarbon and Ecograder that seek to translate these metrics into a specific CO2 figure (in the case of WebsiteCarbon) or a score (in the case of Ecograder).
Sustainable Web Design
Now we know how to measure the impact of our site, it’s time to think about how we can optimize things to make it more sustainable, more performant, and generally a better experience to use.
There are some existing works we can draw on to help us here. In 2016, O’Reilly published “Designing For Sustainability” by Tim Frick. In this book, Tim takes us on a tour of the whys and hows of sustainable design. But we can also draw on a wealth of existing ideas, conference talks and articles which — while not having an explicit focus on sustainability — have a huge overlap with the philosophy of sustainable web design. Particularly good examples here are Brad Frost’s side-project, “Death To Bullshit”, Heydon Pickering’s articles and talks about writing less damn code, and Adam Silver’s blog post, “Designing For Actual Performance.”
If we’re doing a complete redesign of a website, or starting a new one from scratch, we can start with some really high-level questions here. For example, what actually deserves or needs to be on a homepage? And more specifically, what value does each element on a homepage bring? As Heydon Pickering puts it:
“The most performant, accessible and easily maintainable feature of a website is the one that you don’t make in the first place.”
I work on the WordPress.com VIP team, so in this vein, I decided to challenge myself by putting together a minimalist WordPress theme to see how far I could take the techniques of sustainable web design. The result is a theme called Susty, and it can be seen in action on the accompanying website I put together: sustywp.com. In that particular example, the website is delivered in just over 6KB of data transfer, which feels good given that the median website is about 1.5MB.
So, what did I do? Well, I’ll tell you.
Reduce Network Requests
As I have outlined above, network requests are something we can easily measure, so they make for a good starting point. In putting Susty together, I noticed there were a number of HTTP requests going on that didn’t appear to be necessary. For example, WordPress bundles some CSS and JavaScript that detects the usage of emojis and makes sure they don’t appear as illegal characters. There’s nothing inherently wrong with this, but if you aren’t planning to use emojis, or you’re happy and confident that the various system defaults will have you covered, you can prevent these from loading.
This represents a relatively meager saving, but by establishing a philosophy of pruning unwanted code and requests from our pages, we can make much more significant performance improvements. For example:
Do we have a carousel of images?
Do we really need all those images? Are they significantly enhancing the user experience? Or could we reduce it to just one, strong image? Or even randomly show one of a selection of images, to give a sense of dynamism to returning users? By the way, the research that has been done here shows that most users neither like nor engage with carousels.
If we are using a lot of images, would we benefit from providing our images using the WebP format for those browsers that support it?
For the longest time, WebP‘s support has been frustratingly limited. But with Firefox due to begin support for it in version 65 (due in January 2019), it’s only a matter of time before remaining stragglers like Safari catch up.
Are we embedding YouTube videos?
An embedded YouTube video typically adds about a megabyte of data transfer before anyone even interacts with it. If only a fraction of our users are actually going to sit and watch the embedded video on our website, could we just link to it instead?
Scrutinise Everything
In this vein, we can also interrogate every aspect of our pages. What really deserves to be there? Does our sidebar add any real value, or have we just put one there because convention dictates that websites have sidebars? So, we’ve added one and filled it with crap.
With Susty, I’ve experimented with the somewhat unorthodox approach of relegating the navigation to its own page. This allows me to have pages that are stripped down to literally the bare essentials, with additional content only being loaded at the user’s explicit request. Susty is so lightweight and so fast that I realized through some user research (aka my partner) that the loading of the menu didn’t really feel like a new page, so I decided to make it look like an overlay, with a cross to dismiss that actually just takes you back to the previous page.
As well as helping me to create pleasingly lightweight pages, the relegated navigation also removes the need for any fancy hide/reveal code for showing it. At this point, I’d like to make it clear that Susty is an example of taking sustainable web design techniques to an extreme (I’m not suggesting it’s an archetype of a good website).
Write CSS Like Your Grandmother
When it comes to serious performance enhancement, we should bear in mind that literally every character of code counts. Every character represents a byte, and even after they’ve been compressed by gzip, they’re still taking up weight. CSS is a domain where we often see a lot of bloat. Fortunately, there are a growing number of increasingly complex tools that can help you weed out unused CSS. This fantastic post by Sarah Dayan outlines how she reduced her CSS bundle from 259KB to 9KB!
If we’re starting from scratch, perhaps we should think more deeply about how we write CSS in the first place. Heydon Pickering wrote an excellent post about how we can write CSS in a way that plays to the strengths of how the syntax was designed, and how this can help developers prevent repetition. Heydon also points out how much wastage goes on with excessive usage of divs and classes — both in HTML and CSS.
What Are You Analyzing?
It seems to have become more-or-less ubiquitous on the web for everyone to analyze what their website’s visitors do via tools like Google Analytics, KISSmetrics, Piwik, etc. While I have no doubt that there are legitimate use cases, do we really need analytics on every website? I, for one, have typically added Google Analytics to every site I manage as a matter of course. But it dawned on me relatively recently that for most of the websites in question, this has been an almost completely pointless endeavor: “Oh, six people came to this post via Facebook today.” Who cares?
Unless you really need it, and you’re going to analyze and act upon the data, just ditch analytics and find a better way to spend your time than gawping at the mundanity of how many people visited website X today.
As well as adding to your page weight, usage of something like Google Analytics raises ethical questions around the data you’re collecting on your users on Google’s behalf, i.e. there’s a reason Google provides you with Analytics for free.
So far, our focus has been almost entirely on the front-end, but a lot of this is made irrelevant if we don’t also optimize things on the server-side. I’ve already mentioned it a couple of times, but we should absolutely enable gzip compression at all times.
We should make serving our website as easy for our server as possible. I predominantly use Nginx, and I have a particular fondness for FastCGI cache and have found it to be especially efficient. If you have shell access to your own server, here’s a post that explains how to configure it. There are less technical options if you don’t have (or don’t want) as much control over your server. A particular favorite in the WordPress space is WP Super Cache.
We should use HTTP2 over HTTPS. Using HTTPS opens up a world of new web technologies like service workers that allow us to treat the network itself as a nice-to-have. If you want to learn more about this, I highly recommend Jeremy Keith’s new book, “Going Offline.”
Note: You also may want to investigate Google’s PageSpeed Module, available for both Apache and Nginx.
Finally, the biggest impact we can have here is to host our websites in data centers powered by renewable energy. In the UK, I can highly recommend Krystal and Kualo in terms of companies with which I directly host my sites. (For a full directory of green web hosts, check out The Green Web Foundation.)
In Conclusion
I hope I have convinced you that it’s worth putting in the effort to make our websites more sustainable. Especially given that in the process we also make our websites:
More performant,
More user-friendly,
More accessible,
More server-friendly,
Better optimized for search engines.
A response that some people have to the idea of sustainable web design — which is not unreasonable — is that it seems to be a very small concession to the environmental cause. Of course, how much of an impact you can have depends on how busy the websites are that you work on. But as well as helping the web become a bit more environmentally friendly, sustainable web design is fundamentally best practice web design.
It’s also worth thinking about offsetting the carbon emissions that you can’t avoid. Carbon offsetting is sometimes derided, and with good cause. The main problem with offsetting is that typically the term over which carbon will be offset is quite long. For example, with tree planting, the figure given for an amount of carbon sequestering is typically based over a 100-year period. So, in terms of reducing carbon emissions now, it’s not really a solution. But it is better than nothing.
The motto of myclimate is to do your best, and offset the rest. I have written a blog post about rolling your own carbon offset scheme. I also highly recommend the 1% For The Planet initiative. Finally, if you are a business owner and would like to join an alliance of companies that want to see better social, environmental and economic justice, check out the Certified B Corporation scheme.
