Easy Z Modal is a simple, customizable and dynamic jQuery plugin to create modals and dialog boxes.
by via jQuery-Plugins.net RSS Feed
Wednesday, September 2, 2015
Does the New Google Logo Really Look Like Comic Sans?
Google doesn’t change it’s brand often, but when it does, it’s hard to ignore it. From search pages, to app icons, to browser tabs, it is a brand that is stitched into the linings of our online lives. Yesterday the ‘Big G’ rolled out probably their biggest re-branding effort ever. Here it is. As you […]
Continue reading %Does the New Google Logo Really Look Like Comic Sans?%
by Alex Walker via SitePoint
Browser Trends September 2015: IE’s Demise Edges Closer
In August, Chrome exceeded one in every two users for the first time. Can it keep up the pace in September's StatCounter statistics? …
Worldwide Desktop & Tablet Browser Statistics, July to August 2015
The following table shows browser usage movements during the past month.
| Browser | July | August | change | relative |
|---|---|---|---|---|
| IE (all) | 17.18% | 15.99% | -1.19% | -6.90% |
| IE11 | 10.84% | 9.94% | -0.90% | -8.30% |
| IE10 | 1.73% | 1.66% | -0.07% | -4.00% |
| IE9 | 1.95% | 1.83% | -0.12% | -6.20% |
| IE6/7/8 | 2.66% | 2.56% | -0.10% | -3.80% |
| Edge | 0.05% | 0.74% | +0.69% | +1,380.00% |
| Chrome | 51.89% | 52.97% | +1.08% | +2.10% |
| Firefox | 15.68% | 15.60% | -0.08% | -0.50% |
| Safari | 4.20% | 3.77% | -0.43% | -10.20% |
| iPad Safari | 5.54% | 5.53% | -0.01% | -0.20% |
| Opera | 1.81% | 1.79% | -0.02% | -1.10% |
| Others | 3.65% | 3.61% | -0.04% | -1.10% |
Continue reading %Browser Trends September 2015: IE’s Demise Edges Closer%
by Craig Buckler via SitePoint
Measuring JavaScript Functions’ Performance
Performance has always played a crucial part in software. On the web, performance is even more important as our users can easily change website and visit one of our competitors if we offer them slow pages. As professional web developers, we have to take this issue into account. A lot of old web performance optimization best practices, such as minimizing requests, using a CDN and not writing rendering blocking code, still apply today. However, as more and more web apps are using JavaScript, it’s important to verify that our code is fast.
Suppose that you have a working function but you suspect it’s not as fast as it could be, and you have a plan to improve it. How do you prove this assumption? What’s the best practice for testing the performance of JavaScript functions today? Generally, the best way to achieve this task is to use the built-in performance.now() function and measure the time before and after your function executes.
In this article we’ll discuss how to measure code execution time and techniques to avoid some common pitfalls.
Performance.now()
The High Resolution Time API offers a function, named now() that returns a DOMHighResTimeStamp object. It's a floating point number that reflects the current time in milliseconds accurate to a thousandth of a millisecond
. Individually, the number doesn’t add much value to your analysis, but a difference between two such numbers gives an accurate description of how much time has passed.
In addition to the fact that it is more accurate than the built-in Date object, it's also “monotonic”. That means, in simple terms, that it’s not affected by the system (e.g. your laptop OS) periodically correcting the system time. In even simpler terms, defining two instances of Date and calculating the difference isn’t representative of the time that has passed.
The mathematical definition of “monotonic” is (of a function or quantity) varying in such a way that it either never decreases or never increases
.
Another way of explaining it, is by trying to imagine using it around the times of the year when the clocks go forward or go back. For example, when the clocks in your country all agree to skip an hour for the sake of maximizing daytime sunshine. If you were to make a Date instance before clocks go back an hour, and another Date instance afterwards, looking at the difference it would say something like “1 hour and 3 seconds and 123 milliseconds”. With two instances of performance.now() the difference would be “3 seconds 123 milliseconds and 456789 thousands of a millisecond”.
In this section, I won't cover this API in detail. So if you want to learn more about it and see some example of its use, I suggest you to read the article Discovering the High Resolution Time API.
Continue reading %Measuring JavaScript Functions’ Performance%
by Peter Bengtsson via SitePoint
JAIL – jQuery Asynchronous Image Loader
JAIL is a jQuery plugin that lazy load images making your page load faster. Images are downloaded when they are visible or when they become visible inside the viewport
by via jQuery-Plugins.net RSS Feed
Color Alchemy with Less: Creating Color Schemes and Palettes
Color is one of the most important elements in any visual design. When properly used, it can have great impact on your web site or application. But knowing color theory solely is not enough to achieve such impact. You need to have the right tool belt to operate easily and successfully with the multitude of colors. Fortunately, Less solves this practical problem by providing plenty of color functions to work with.
In this tutorial, I’ll explore how to use some of these color functions, in conjunction with other Less features, to produce flexible and reusable mixins for color manipulation.
Creating Color Schemes
When attempting to create color schemes with Less, most people take the most obvious approach, which looks like this:
[code language="scss"]
@base-color: #00ff00;
@triad-secondary: spin(@base-color, 120);
@triad-tertiary: spin(@base-color, -120);
[/code]
This method uses variables and Less’s spin() function to create a color scheme (triadic, in our case). This works fine, but for me it’s not particularly reusable and not flexible enough. Fortunately, the issue can be resolved by using mixins. Let’s see what I mean.
[code language="scss"]
.analog(@color, @variant, @property) {
@first: spin(@color, 30);
@second: spin(@color, -30);
@list: @first, @second;
@return: extract(@list, @variant);
@{property}: @return;
}
.triad(@color, @variant, @property) {
@first: spin(@color, 120);
@second: spin(@color, -120);
@list: @first, @second;
@return: extract(@list, @variant);
@{property}: @return;
}
.quad(@color, @variant, @property) {
@first: spin(@color, 90);
@second: spin(@color, -90);
@third: spin(@color, 180);
@list: @first, @second, @third;
@return: extract(@list, @variant);
@{property}: @return;
}
[/code]
The above code creates three types of color schemes. I’ll explain only the last one, because the first two have the same structure and they don’t need individual explanations.
The .quad() mixin takes three parameters. The first one sets the base color for the scheme. The second one tells the mixin which color variant to return. And the third one defines which CSS property to use when Less compiles the code. Inside the mixin’s body, the spin() function creates the three available color variants in a quad scheme, then these variants are put in a list. The extract() function gets the desired variant, defined in the second parameter. And finally, with the help of variable interpolation, the color variant is assigned to the defined CSS property.
We can now put the above code in a separate file called color_schemes.less and use it as follows:
[code language="scss"]
@import "color_schemes.less";
@base-color: #00ff00;
div {
width: 200px;
height: 100px;
border: thick solid;
.quad(@base-color, 3, border-color);
.quad(@base-color, 2, color);
.quad(@base-color, 1, background-color);
}
[/code]
Here we import the file with the color schemes, and then we define the base color for our website or application. The last three lines in the div rule set, define the colors for the border-color, color, and background-color properties.
As you can see, the mixin can be used with any property whose expected value is a color. Besides, it’s super easy to see for which property a particular statement is used; just take a look at the end, and boom, we know it. For example, in the last statement you can clearly see that the first color variant of the quad scheme will be used as the value for the background-color property. Pretty cool, huh?
Continue reading %Color Alchemy with Less: Creating Color Schemes and Palettes%
by Ivaylo Gerchev via SitePoint
Watch: Adding a Lap Logger to a React Stopwatch
Adding a lap-timer is no walk in the park, but what good is a stopwatch that only tracks one lap? We'll take all we've learned about state, lists, and conditional rendering to add this new feature. When we're done you'll be running laps of joy around your computer and timing them accurately.
This is part 3 of the Building a Stopwatch in React series.
Loading the player...
Continue reading %Watch: Adding a Lap Logger to a React Stopwatch%
by Michael Chan via SitePoint
Subscribe to:
Posts (Atom)