Post pobrano z: Hum Creative
Archiwum miesiąca: luty 2017
Paul Valentine
Post pobrano z: Paul Valentine
Michael K Williams asks Am I Typecast?
Post pobrano z: Michael K Williams asks Am I Typecast?
Is Michael K Williams being typecast? Are you? The Atlantic invites audiences to question their assumptions in a short film starring an actor known for the nuanced complexity of the characters he portrays. The film is the centerpiece of Question Your Answers, a new campaign from American magazine The Atlantic, built on The Atlantic’s 160-year legacy and the idea of of questioning conventional wisdom. In the two-and-a-half-minute film, “Typecast,” we see Michael K Williams, known for such roles as Omar Little in The Wire and Chalky White in Boardwalk Empire, wondering aloud if he’s being typecast. But we soon discover that he’s not alone: He’s debating this complicated question with four versions of himself, all representing different aspects of who he’s been and who he is today.
“Question Your Answers” arrives at a moment of great conversation and debate about the state of media. On social media and at TheAtlantic.com, the campaign urges audiences to break down their information silos, challenge established answers, and embrace a lifestyle of continuous interrogation and exploration.
In a note introducing the campaign, The Atlantic’s President Bob Cohn writes: “The central premise of the campaign is that The Atlantic has a 160-year tradition of questioning established answers. We scrutinize our own (and others’) opinions; we challenge the received wisdom; we’re open to ideas that mess with our assumptions. We do all this as part of our commitment to bring clarity and original thinking to the most consequential issues of the day.”
“It seems like everywhere you look, people are shouting their opinions,” says Wieden+Kennedy creative director Jaclyn Crowley. “The Atlantic respects introspection and the vulnerability that comes with exploring and questioning your beliefs. This kind of thinking is not only refreshing, but necessary.”
The film’s director, David Shane of O Positive Films, says: “The idea is so smart and so simple—The Atlantic allows and encourages you to look at all sides of an issue. We tried to create the vibe of four dudes, four friends just hanging out and having this kind of thoughtful discussion. The degree of difficulty of this performance is actually hard to fully understand. He was playing, in effect, four characters, and trying to keep track of them.”
Michael K Williams Am I Typecast Credits
The QuestionsAnswers campaign campaign was developed at Wieden+Kennedy New York by executive creative director Karl Lieberman, creative directors Jaclyn Crowley and Al Merry, copywriter Brock Kirby, project manager Danielle Rounds, head of integrated production Nick Setounski, media director David Stopforth, executive producer Alison Hill, media strategist Sophie Novick, social media director Jessica Breslin, strategist Brian Ritter, account team Sara Jagielski, Patrick O, Lindsey Tim, PR and publishing director Teressa Lezzi, and management supervisor Samantha Wagner.
Filming was shot by director David Shane via O Positive with director of photography Maryse Alberti, line producer Marc Grill, executive producer Ralph Laucella,
Editor was Gavin Cutler at MackCut with producer Gina Pagano and assistant editor Pamela Petruski.
Visual effects and colour were produced at The Mill by executive producer Verity Grantham, producer Clairellen Wallin, production coordinator Kate Aspell, shoot supervisor/2D lead artist Antoine Douadi, colour producer Natalie Westerfield, colour coordinator Elizabeth Nagle, colourist Josh Bohoskey, colour assistants Daniel Moisoff, Nate Seymour, Amanda Bernhardt, Zack Wilpon.
A sixteen years old idea? / Une idée qui n’a pas beaucoup vieillie?
Post pobrano z: A sixteen years old idea? / Une idée qui n’a pas beaucoup vieillie?
 |
 |
| THE ORIGINAL? Subaru Legacy “Baby Driver” – 2010 Watch the TV Commercial Source : IAA Awards GOLD Agency : Carmichael Lynch, Minneapolis (USA) |
LESS ORIGINAL IKEA “My Son” – 2016 Watch the TV Commercial Source : Cristal festival SILVER Agency : Buzzman Paris (France) |
Will winning the lottery make you happy?
Post pobrano z: Will winning the lottery make you happy?
Allen Laseter has set the bar quite high on what someone can produce on their own. In this Motionographer Q&A, we find out about the production of Allen’s new film for Ted-Ed as well as what the animation scene is like down in Nashville.
STZAP #4
Post pobrano z: STZAP #4
How to Create Realistic Feet-Inspired Hiking Boots in Adobe Photoshop
Post pobrano z: How to Create Realistic Feet-Inspired Hiking Boots in Adobe Photoshop
Do you love hiking? Upgrade your footwear with a unique pair of foot-inspired boots! In this tutorial, we’ll go over how to manipulate a regular pair of feet to create an overall hiking scene using basic photo manipulation techniques.
Want to add that natural earthy look to all your photos? Browse the incredible selection of Natural Photoshop Actions on GraphicRiver to retouch your work. Or enlist the help of a design professional from Envato Studio for all your photo manipulation needs.
Tutorial Assets
The following assets were used in the production of this tutorial:
1. How to Extract the Feet
Step 1
For the purpose of this tutorial, I’ll be using the original dimensions supported by my Foot Reference to create the composition. Currently it’s 2200 x 2635 pixels, but later on we will crop it down to fit the scene.
Open your photo into Photoshop. Double-Click the background layer to change it to Layer 0. Use the Magic Wand Tool (W) to select the white areas of the background, and hit Delete to get rid of them.
Step 2
Using the Magnetic Lasso Tool (L), begin creating a selection around each foot. Control-J to Duplicate each foot onto its own new layer. When you’re through, you should have two separate layers for each foot. Save file space by Deleting the layer with the scale still on it, and feel free to organize these layers into a new Group.
2. How to Sketch Guidelines for the Boots
Step 1
Use the Move Tool (V) to position the feet lower onto the canvas.
Feel free to experiment with the position of the feet. You can move one slightly back or keep them aligned as I did. Changing the position may make the manipulation a little harder, so just keep that in mind.
Step 2
The next few steps are optional. Feel free to move on without a sketch if necessary. To help me understand how to situate the boots, I’ll need to draw a quick sketch over the feet. This will help me understand the perspective, and where to place the laces, hooks, and collars correctly.
Create a New Layer underneath the feet group and Fill it with white using the Paint Bucket Tool (G). Select a basic Hard Round Brush (B) to sketch two circles located above the ankle on another New Layer.
Merge the two feet layers together. Add a Layer Mask to the merged layer and begin painting black onto the layer mask to hide the top half of the leg. Do this for each foot.
Step 3
The feet are looking a little thin. Select each foot with the Rectangular Marquee Tool (M) and use the Free Transform Tool (Control-T) to make both wider. Adjust the Layer Mask and sketch accordingly.
Step 4
On the sketch layer, draw a basic outline of the boot’s tongue. This will help give us a guideline for where to place the boot reference later.
3. How to Manipulate the Boot Reference
Step 1
Now that we’ve got a good guideline going, we can incorporate the actual boots. First, open your Boot Reference into a separate document and use the Magic Wand Tool (W) to Delete the white background.
Step 2
Use the Polygonal Lasso Tool (L) to make a selection around the left boot’s tongue, collar, and laces. Copy and Paste it into your photo manipulation document. Lower the Opacity slightly so that you can still see the feet underneath.
Position the boot over the left foot, Resizing it and Warping it to fit the foot with the Free Transform Tool (Control-T). Toggle the Visibility of the sketch layer on and off so that it’s not distracting.
Continue manipulating the stock until you’re happy with how the boot fits the foot. Then add a Layer Mask to the boot layer and paint black onto the mask to hide any parts of the boot that you don’t want, using both Hard and Soft Round Brushes.
Step 3
Let’s move on to the right foot. Just like before, make a Selection over the right boot with the Polygonal Lasso Tool (L). Copy and Paste the selection onto a New Layer above the right foot.
This foot is a little tricky, so I’ll slow the process down. Control-T to Free Transform the boot, scaling it down to fit along the right foot. Try your best to match the size of the left one.
While holding the Control key, grab the corners of the Free Transform box and tweak the perspective slightly.
Now Free Transform again, selecting Warp to mold the boot to the foot. Don’t worry about making it fit the leg completely, otherwise you may distort the stock too much.
Step 4
Because the right leg is still showing, we’ll need to mask it out. So select the Layer Mask for the right foot and paint black to hide the rest of the leg.
Just like before, continue to mask any parts of the boot you don’t want. And feel free to clean up the edges by painting on a New Layer with the Brush Tool (B).
4. How to Create the Forest Ground
Step 1
Now that we have the most difficult steps out the way, we can concentrate on the forest ground. Delete the white background layer. Copy and Paste the Grass Reference onto a New Layer beneath the boots. Adjust the Scale and Perspective to make it appear much larger with the Free Transform Tool (Control-T).
Create a New Adjustment Layer of Hue and Saturation, and Right-Click to set it as a Clipping Mask to the grass layer. Desaturate the grass to match the feet with the following settings:
- Hue: 0
- Saturation: -67
- Lightness: -12
Step 2
Merge the layers for the boot and feet together. Control-J to Duplicate the layer, positioning it slightly underneath the first layer.
Go to Image > Adjustments > Hue and Saturation. Bring down the Lightness to 0 to turn the duplicate black.
Then Blur the shadow by going to Filter > Blur > Gaussian Blur, and adding a Radius of 48.4 pixels. Keep the shadow around 54% Opacity when you’re finished.
Step 3
Let’s make the grass look a little more realistic. Add a Layer Mask to the boot layer. Paint black onto the Layer Mask with a Hard Round Brush to reveal the grass underneath the feet.
Step 4
Now Copy and Paste the Ground Reference onto the canvas to add some shrubbery to the scene.
Control-J to Duplicate it, and Flip the copy by going to Edit > Transform > Flip Horizontal. Position the second stock behind the right foot.
Add a Layer Mask to each layer of shrubbery. Paint black onto the white Layer Mask with a Soft Round Brush to hide any harsh lines. Try to blend the shrubbery with the grass as much as possible.
Step 5
The shrubbery is a little too bright for the scene. So set a New Adjustment Layer of Hue and Saturation as a Clipping Mask to both layers. Adjust the Lightness to -16.
Step 6
Before we move on to the final details, let’s change the color of the boot collar. First, create a selection on the collar using the Polygonal Lasso Tool (L). Then go to Layer > New Adjustment Layer > Hue and Saturation to create a Layer Mask of just the collar.
Change the color from orange to purplish-blue by adjusting the Hue to -108.
Repeat the process with the left foot.
5. How to Create Realistic Lighting and Details
Step 1
Now that we have the boot and ground floor ready, we can move on to the finishing details to really make this pop! Start by adding a New Adjustment Layer of Curves as a Clipping Mask to the boot layer. Adjust the Curves for the RGB and Blue channels slightly.
Extract one of the ladybugs from the Ladybug Reference and Paste it onto the canvas. Make it overlap one of the feet for a quirky effect.
Step 2
Now we need to work on the lighting and overall color scheme. Add a New Layer set to Multiply with an Opacity of 55%. Use a dark green color to Paint shadow on the left side to knock out some of the bright greens coming through with a large Soft Round Brush.
Increase the Brush Hardness to 100%. Now paint more shadow all around the boots. Ground them to the forest floor by painting shadow underneath them, and add extra shadow to the laces and boot tongue for more dimension.
Here is a before and after animation of this process. Notice how grounded the boots look now that the shadows have been applied.
Step 3
Let’s change the colors next. To create an overall tint of green, add a New Adjustment Layer of Color Lookup with the following settings:
- 3DLUT File: TensionGreen.3DL
Follow up with another New Adjustment Layer of Brightness and Contrast with the following settings:
- Brightness:-27
- Contrast:15
Step 4
Always try to leave highlights for towards the end, when you have a better understanding of the lighting scheme. Now add a New Layer set to Overlay. Paint white onto the right side of the scene with a large Soft Round Brush.
Continue to add more highlights to the boot and ground. Here I added them to the boot tongue and lower left region.
Boots are known for having a shiny, leathery texture. Add some sheen to the boots by painting more highlights onto the foot, toes, and boot details. Make those hooks sparkle! Take note of the subtle difference with this animation below.
6. How to Sharpen and Add Dirt
Step 1
Time for the last details! Boots in the forest won’t look this clean. So add dirt by creating a New Layer and using the Chalk Brush to paint dark brown dirt all over the boots.
Step 2
Next, select the Crop Tool (C) to Crop the composition and make it slightly smaller. This will help draw the eye to the center while reinforcing the perspective.
Step 3
For crisp, clear details, we’ll sharpen this photo manipulation with a High Pass Filter. First, select all your layers and Merge them together. Control-J to create a Duplicate of your merge.
Go to Filter > Other > High Pass, adding a Radius of 3.4 pixels. Set the Layer Blend Mode to Soft Light when you’re through.
Step 4
Continue to play with Adjustment Layers to tweak the colors and lighting. To finish things up, I’ll be using this last Color Lookup Adjustment Layer with the following settings:
- 3DLUT File: Fuji F125 Kodak 2395
And that’s it! Check out the final result below!
All Done! Let’s Go Hiking!
Finding photo references that can blend easily together are a huge part of great photo manipulation. And with a little patience, basic Photoshop tools, and a creative eye, you too can manipulate stocks with finesse and ease.
Browse the amazing selection of Natural Photoshop Actions on
GraphicRiver to apply natural, forest floor colors to any photo manipulation
instantly.
I really hope you enjoyed this tutorial. Feel free to leave any questions in the comments below.
HTTP/2 – A Real-World Performance Test and Analysis
Post pobrano z: HTTP/2 – A Real-World Performance Test and Analysis
Perhaps you’ve heard of HTTP/2? It’s not just an idea, it’s a real technology and slowly but surely, hosting companies and CDN services have been releasing it to their servers. Much has been said about the benefits of using HTTP/2 instead of HTTP1.x, but the proof the the pudding is in the eating.
Today we’re going to perform a few real-world tests, perform some timings and see what results we can extract out of all this.
Why HTTP/2?
If you haven’t read about HTTP/2, may I suggest you have a look at a few articles. There’s the HTTP/2 faq which gives you all the nitty gritty technical details whilst I’ve also written a few articles about HTTP/2 myself where I try to tone-down the tech and focus mostly on the why and the how of HTTP/2.
In a nutshell, HTTP/2 has been released to address the inherent problems of HTTP1.x
- HTTP/2 is binary instead of textual like HTTP1.x – this makes it transfer and parsing of data over HTTP/2 inherently more machine-friendly, thus faster, more efficient and less error prone.
- HTTP/2 is fully multiplexed allowing multiple files and requests to be transferred at the same time, as opposed to HTTP1.x which only accepted one single request / connection at a time.
- HTTP/2 uses the same connection for transferring different files and requests, avoiding the heavy operation of opening a new connection for every file which needs to be transferred between a client and a server.
- HTTP/2 has header compression built-in which is another way of removing several of the overheads associated with HTTP1.x having to retrieve several different resources from the same or multiple web servers.
- HTTP/2 allows servers to push required resources proactively rather than waiting for the client browser to request files when it thinks it need them.
These things are the best (if simplistic) depiction of how HTTP/2 is better than HTTP1.x. Rather than the browser having to go back to the server to fetch every single resource, it’s picking up all the resources and transferring them at once.
An semi-scientific test of HTTP/2 performance
Theory is great, but it’s more convincing if we can see some real-data and real performance improvements of HTTP/2 over HTTP1.x We’re going to run a few tests to determine whether we see a marked improvement in performance.
Why are we calling this a semi-scientific test?
If this were a lab, or even a development environment where we wanted to demonstrate exact results, we’d be eliminating all variables and just test the performance of the same HTML content, one using HTTP1.x and one using HTTP/2.
Yet (most of us) don’t live in a development environment. Our web applications and sites operate in the real world, in environments where fluctuations occur for all sorts of valid reasons. So while lab testing is great and is definitely required, for this test we’re going out in the real-world and running some tests on a (simulated) real website and compare their performance.
We’re going to be using a default one-page Bootstrap template (Zebre) for several reasons:
- It’s a very real-world example of what modern website looks like today
- It’s got quite a varied set of resources which are typical of sites today and which would typically go through a number of optimizations for performance under HTTP1.x circumstances
- 25 images
- 6 JS scripts
- 7 CSS files
- It’s based on WordPress so we’ll be able to perform a number of HTTP1.x based optimizations to push its performance as far as it can go
- It was given out for free in January by ThemeForest. This was great timing, what better real-world test than using a premium theme by an elite author on ThemeForest?
We’ll be running these tests on a brand new account powered by Kinsta managed WordPress hosting who we’ve discovered lately, and whose performance we really find great. We do this because we want to avoid the stressed environments of shared hosting accounts. To reduce the external influence of other sites operating on the same account at the same time, this environment will be used solely for the purpose of this test.
We ran the tests on the lowest plan because we just need to test a single WordPress site. In reality, unlike most hosting services, there is no difference in speed/performance of the plans. The larger plans just have the capacity for more sites. We then set up one of the domains we hoard (iwantovisit.com) and installed WordPress on it.
We’ve also chosen to run these tests on WordPress.
The reason for doing that is for a bit of convenience rather than anything else. Doing all of these tests on manual HTML would require quite a lot of time to complete. We’d rather use that time to do more extensive and constructive tests.
Using WordPress, we can enable such plugins as:
- A caching plugin (to remove generation time discrepancies as much as possible)
- Combination and minification plugin to perform optimizations based on HTTP1.x
- CDN plugin to easily integrate with a CDN whilst performing HTTP/2 tests integrated with a CDN
We setup the Zebre theme and installed several plugins. Once again, this makes the test very realistic. You’re hardly going to find any WordPress sites without a bunch of plugins installed. We installed the following:
We also imported the Zebre theme demo data to have a nicely populated theme with plenty of images, making this site an ideal candidate for HTTP/2 testing.
The final thing we did was to make sure there is page caching in place. We just want to make sure we were not suffering from drastic fluctuations due to page generation times. The great thing is that with Kinsta there’s no needed for any kind of caching plugin as page caching is fully built into the service at the server-level.
The final page looked a little like this:
And this is the below the fold:
We’re ready for the first tests.
Test 1 – HTTP1 – caching but no other optimizations
Let’s start running some tests to make sure we have a good test bed and get some baseline results.
We’re running these tests with only WordPress caching – no other optimizations.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Vancouver | 3.3s | 7.3Mb | 82 |
| Pingdom tools | New York | 1.25s | 7.3Mb | 82 |
There’s clearly something fishy going on. The load times are much too different. Oh yes: Google Cloud platform, Central US servers east are located in Iowa, making the test location of Pingdom tools New York much closer than Vancouver, skewing the results in favor of New York.
You probably know that if you want to improve the performance of your site, there is one very simple solution: host your site or application as physically close as possible to the location of your visitors. That’s the same concept CDNs use to boost performance. The closer the visitors to the server location of the site, the better the loading time.
For that reason, we’re going to run two types of tests. One is going to have a very close location between the hosting service and the test location. For the other, we’re going to choose to amplify the problem of distance. We’re thus going to perform a trans-atlantic trip with our testing, from the US to Europe, and see whether the HTTP/2 optimizations results in better performance or not.
Let’s try to find a similar testing location on both test services. Dallas, Texas is a common testing ground, so we’ll use that for the physically close location. For the second location, we’re going to use London and Stockholm, since there isn’ a shared European location.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| Pingdom tools | Dallas | 2.15s | 7.3Mb | 82 |
That’s better. Let’s run another couple of tests.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 1.6s | 7.3Mb | 83 |
| Pingdom tools | Dallas | 1.74s | 7.3Mb | 82 |
| GTMetrix | London | 2.6s | 7.3Mb | 82 |
| Pingdom tools | Stockholm | 2.4s | 7.3Mb | 82 |
You might notice there are a few fluctuations in the requests. We believe these are coming from external scripts being called, which sometimes differ in the number of requests they generate. In fact, although the loading times seem to vary by about a second, by taking a look at the waterfall graph, we can see that the assets on the site are delivered pretty consistently. It’s the external assets (specifically: fonts) which fluctuate widely.
We can see clearly also how the distance affects the loading time significantly by about a second.
Before we continue, you’ll also notice that our speed optimization score is miserable. That’s why for our second round of tests we’re going to perform a number of speed optimizations.
Test 2 – HTTP1 with performance optimizations and caching
Now, given that we know that HTTP1.x is very inefficient in the handling of requests, we’re going to do a round of performance optimizations.
We’re going to install HummingBird from WPMUDEV on the WordPress installation. This is a plugin which handles page load optimizations without caching. Exactly what we need.
We’ll be enabling most of the optimizations which focus on reducing requests and combining files as much as possible.
- Minification of CSS and JS files
- Combining of CSS and JS files
- Enabling of GZIP compression
- Enabling of browser caching
We’re not going to optimize the images because this would totally skew the results.
As you can see below, following our optimization, we have a near perfect score for everything except images. We’re going to leave the images unoptimized on purpose so that we retain their large size and have a good „load” to carry.
Let’s flush the caches and perform a second run of tests. Immediately we can see a drastic improvement.
Never mind the C on YSlow. It’s because we’re not using a CDN and some of the external resources (the fonts) cannot be browser cached.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 1.9s | 7.25Mb | 56 |
| Pingdom tools | Dallas | 1.6s | 7.2Mb | 56 |
| GTMetrix | London | 2.7s | 7.25Mb | 56 |
| Pingdom tools | Stockholm | 2.28s | 7.3Mb | 56 |
We can see quite a nice improvement on the site. Next up, we’re going to enable HTTPS on the site. This is a prerequisite for setting up HTTP/2.
Test 3 – HTTP/2 without optimizations and caching
We’ll be using the Let’s Encrypt functionality to create a free SSL certificate. This is built into Kinsta, which means setting up HTTPS should be pretty straightforward.
Once we’ve generated an HTTPS certificate, we’ll be using the Really Simple SSL WordPress plugin to force HTTPS across the site.
This plugin checks whether a secure certificate for the domain exists on your server, if it does, it forces HTTPS across your WordPress site. Really and truly, this plugin makes implementing HTTPS on your site a breeze. If you’re performing a migration from HTTP to HTTPS, do not forget to perform a full 301 redirection from HTTP to HTTPS, so that you don’t lose any traffic or search engine rankings whilst forcing HTTPS on your site.
Once we’ve fully enabled and tested HTTPS on our website, you might need to do a little magic to start serving resources over HTTP/2, although most servers today will switch you directly to HTTP/2 if you are running an SSL site.
Kinsta runs on Nginx, and enables HTTP/2 by default on SSL sites, so enabling SSL is enough to switch the whole site to HTTP/2.
Once we’ve performed the configuration our site should now be served on HTTP/2. To confirm that the site is running on HTTP/2, we’ve installed this nifty chrome extension which checks which protocols are supported by our site.
Once we’ve confirmed that HTTP/2 is up and running nicely on the site, we can run another batch of tests.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 2.7s | 7.24Mb | 82 |
| Pingdom tools* | Dallas | 2.04s | 7.3Mb | 82 |
| GTMetrix | London | 2.4s | 7.24Mb | 82 |
| Pingdom tools* | Stockholm | 2.69s | 7.3Mb | 82 |
*Unfortunately, Pingdom tools uses Chrome 39 to perform the tests. This version of Chrome does not have HTTP/2 support so we won’t be able to realistically calculate the speed improvements. We’ll run the tests regardless because we can have a benchmark to compare with.
Test 4 – HTTP/2 with performance optimizations and caching
Now that we’ve seen HTTP/2 without any performance optimizations, it’s also a good idea to actually check whether HTTP1 based performance optimizations can and will make any difference when we have HTTP/2 enabled.
There are two ways of thinking about this:
- Against: To perform optimizations aimed at reducing connections and size, we are adding performance overhead to the site (whilst the server performs minification and combination of files), therefore there is a negative effect on the performance.
- In favor: Performing such minification and combination of files and other optimizations will have a performance improvement regardless of protocol, particularly minification which is essentially reducing the size of resources which need to be delivered. Any performance overhead can be mitigated using caching.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 1.0s | 6.94Mb | 42 |
| Pingdom tools** | Dallas | 1.45s | 7.3Mb | 56 |
| GTMetrix | London | 2.5s | 7.21Mb | 56 |
| Pingdom tools** | Stockholm | 2.46s | 7.3Mb | 56 |
**HTTP/2 not supported
Test 5 – CDN with performance optimizations and caching (no HTTP/2)
You’ve probably seen over and over again how one of the main ways to improve the performance of a site is to implement a CDN (Content Delivery Network).
But why should a CDN still be required if we are now using HTTP/2?
There is still going to be a need for a CDN, even with HTTP/2 in place. The reason is that besides a CDN improving performance from an infrastructure point of view (more powerful servers to handle the load of traffic), a CDN actually reduces the distance that the heaviest resources of your website need to travel.
By using a CDN, resources such as images, CSS and JS files are going to be served from a location which is (typically) physically closer to your end user that your website’s hosting server.
This has an implicit performance advantage: the less content needs to travel, the faster your website will load. This is something which we’ve already encountered in our initial tests above. Physically closer test locations perform much better in loading times.
For our tests, we’re going to run our website on an Incapsula CDN server, one of the CDN services which we’ve been using for our sites lately. Of course, any CDN will have the same or similar benefits.
There are a couple of ways that your typical CDN will work:
- URL rewrite: You install a plugin or write code such that the address of resources are rewritten such that they are served from the CDN rather than your site’s URL
- Reverse proxy: you make DNS changes such that the CDN handles the bulk of your traffic. The CDN service then sends the requests for dynamic content to your web server.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 1.5s | 7.21Mb | 61 |
| Pingdom tools | Dallas | 1.65s | 7.3Mb | 61 |
| GTMetrix | London | 2.2s | 7.21Mb | 61 |
| Pingdom tools | Stockholm | 1.24s | 7.3Mb | 61 |
Test 6 – CDN with performance optimizations and caching and HTTP/2
The final test which we’re going to perform is implementing all possible optimizations we can. That means we’re running a CDN using HTTP/2 on a site running HTTP/2, where all page-load optimizations have been performed.
| Testing Site | Location | Page Load time | Total Page Size | Requests |
|---|---|---|---|---|
| GTMetrix | Dallas | 0.9s | 6.91Mb | 44 |
| Pingdom tools** | Dallas | 1.6s | 7.3Mb | 61 |
| GTMetrix | London | 1.9s | 6.90Mb | 44 |
| Pingdom tools** | Stockholm | 1.41s | 7.3Mb | 61 |
**HTTP/2 not supported
Nice! We’ve got a sub-second loading time for a 7Mb sized website! That’s an impressive result if you ask me!
We can clearly see what a positive effect HTTP/2 is having on the site – when comparing the loading times, you can see that there is a 0.5 second difference on the loading times. Given that we’re operating in an environment which loads in less than 2 seconds in the worst-case scenario, a 0.5 second difference is a HUGE improvement.
This is the result which we were actually hoping for.
Yes, HTTP/2 does make a real difference.
Conclusion – Analysis of HTTP/2 performance
Although we tried as much as possible to eliminate fluctuations, there are going to be quite a few inaccuracies in our setup, but there is a very clear trend. HTTP/2 is faster and is the recommended way forward. It does make up for the performance overhead which is introduced with HTTPS sites.
Our conclusions are therefore:
- HTTP/2 is faster in terms of performance and site loading time than HTTP1.x.
- Minification and other ways of reducing the size of the web page being served is always going to provide more benefits than the overhead required to perform this „minification”.
- Reducing the distance between the server and the client will always provide page loading time performance benefits so using a CDN is still a necessity if you want to push the performance envelope of your site, whether you’ve enabled HTTP/2 or not.
What do you think of our results? Have you already implemented HTTP/2? Have you seen better loading times too?
HTTP/2 – A Real-World Performance Test and Analysis is a post from CSS-Tricks
New Course: Designing Covers for Children’s Books
Post pobrano z: New Course: Designing Covers for Children’s Books
.jpg)
Do you want to know how to create a fantastic children’s book cover?
Our new course, Designing Covers for Children’s Books, will teach you the essential skills and take you through a practical design project from start to finish.
What’s even better is that this short course consists of just seven bite-sized video lessons with a total viewing time of under an hour, so no matter how busy your life is right now, you can easily fit it in around your other commitments.
What You’ll Learn
In this course, experienced designer Tyrus Goshay will be discussing the steps any artist or designer can take to create an engaging and noticeable cover for children’s books. You will learn about composition, the Golden Mean, how to create quick thumbnails, and the power of negative space vs. positive space.
You will pretend that you are designing for the client, and you will follow the steps that you would normally use when freelancing.
Watch the Introduction
Take the Course
You can take our new course straight away with a free 10-day trial of our monthly subscription, which gives you unlimited access to our full library of hundreds of courses. If you decide to continue, it costs just $15 a month.
And if you need a head start with your designs, you can find tons of graphics for kid-friendly illustrations over on Envato Market.
5 clever products to stay organized
Post pobrano z: 5 clever products to stay organized
Staying organized isn’t that hard if you use the right tools, in this post we see a few designs that can help you clean up your mess. 1. House necklace display A cute decoration that also carefuly displays your necklaces. 2. Miniature File Cabinet for Business Cards This tiny cabinet is just the right size to […]