The Bose QuietComfort 25 headphones are an absolutely superb piece of audio technology that get their design, noise cancellation, and overall sound performance almost perfectly right.
They are a bit on the expensive side, but the price is worth the quality you get with these headphones.
Overview
The QuietComfort 25 Headphone set is one of the newest members in the Bose QuietComfort family of headphones and they’re a definite improvement over the previous offerings – particularly the recently released QuietComfort 15 model.
On the whole these latest headphones are a superb noise cancelling piece of audio technology. But they could also use a few minor improvements, especially in general sound quality and level of noise-cancellation.
Nonetheless an extremely comfortable design and highly dynamic clear sound, the QuietComfort 25 series of Bose headphones creates what we could safely call an outstanding set of noise-cancelling headphones.
Specs
Headphone type: Over-ears
Closed: Yes
Weight: 195 grams
Noise-cancelling: Yes
Cable length: 1.4 meters
Connections: 3.5 mm stereo
Channels: Stereo
Inline Controls: Volume, Mute, Microphone
Drivers per ear: 1
Colors: Black and white
Audio Performance
In terms of audio performance in general, the Bose QuietComfort 25 perform their job well. The headphones offer a solid balance of frequencies without ever leaning more towards one over another part of the frequency range. As a result, their capacity for low end sound may not be as good as that of certain other more bass oriented headphones. But at the same time sharper & higher sounds can be enjoyed with wonderful crispness.
Overall, detail and clarity are great with the above-mentioned level of balance and this makes the QuietComfort 25 one excellent pair of high-end multi-purpose speakers.
Piano and guitar sounds maintain an excellent level of depth and richness while sharper sounds like those produced by percussion instruments hit hard without being overly harsh. Once again, the balance of the QuietComfort 25 is strongly at work here. It’s also worth mentioning that the strongest point of the QuietComfort 25 would have to be their ability to produce a fine, crystalline treble that sounds crisp even on very high notes.
Overall the sound quality of the QuietComfort 25 is a bit less warm and low key than what was the case in the Bose QuietComfort 15, the company’s recent previous headphones in the QuietComfort family.
However the balance between low and high frequencies that’s found in the 25 edition creates some superior sound quality with a wider range of music genres, and works particularly well with more upbeat “exciting” sounds.
Noise Cancellation
The Bose QuietComfort 25 offer a level of noise cancellation that could be best described as excellent. While they could still do a better job in this one area, the headphones are particularly good at cancelling out lower background noises. Thus noises like chatter from people, the sounds of an office setting and mechanical sounds like air conditioning vents and car motors are completely hammered out of your hearing range.
On the other hand sharper, closer sounds like those of a human voice talking very close by or directly to you are only reduced. Thus it’s possible to use the 25 headphones with some great music and still keep up with a basic conversation.
The most value of this noise cancelling technology comes from the ability to reduce background noises which are consistent. This makes these headphones perform at their peak (of noise cancellation) in offices, airplanes, buses and busy open places like cafeterias.
Design
Good comfortable design is just about as crucial as solid noise cancellation and rich audio performance in a pair of headphones. In this regard the Bose QuietComfort 25 headphones really had some thought put into them.
Their overall ergonomics are just about as comfortable as they can be in a pair of headphones. They rest easily over the ears without ever becoming uncomfortable or painful to wear. The clamp force of the ear cups is perfectly balanced –they hold onto the head firmly enough to feel secure without eventually feeling like they squeeze too hard.
Furthermore, aesthetics are better than ever in the QuietComfort 25. There are fewer seams to be seen and while the majority of the headphone body is made of plastic, metal earcup domes, a fabric headband, and a suede-like interior all working together to create a more elegant and luxurious experience.
The overall construction of the QuietComfort 25 is furthermore very solid and won’t inspire fear of the headphones easily breaking just because you carry them around with you while travelling.
Finally, one of the ear cups opens up via a hidden flap and can take a single AAA battery that will give the QuietComfort 25 a manufacturer-claimed battery life of about 35 hours with heavy use.
But passive listening can still be done even after the battery dies. So if you don’t need to use the noise cancellation feature or built-in amp technology, you’re good to go for listening to music at a slightly reduced level of depth.
Price
The Bose QuietComfort aren’t cheap by any means, but they’re also not extraordinarily expensive as far as high-end headphones go. The model is currently retailing for $299.99 on most major online retailers.
Many posts and guides have been published online with a direct focus on web design & user experience. These resources have ultimately become scattered but still operate as serious tools for anyone who builds interfaces on the web or on mobile devices.
A brand new website named The Web Field Manual attempts to collect as many resources together in one location.
The site is meant to be a collection of tools, best practices, tips, reference links, and so many detailed topics related to design & development. Web Field Manual has an individual page for coding topics like CSS, SVG, and JavaScript.
Every person who works to craft interfaces from designers to developers could learn something from this website. It’s ultimately geared towards anyone who wants to learn more about the industry with a focus on the highest-rated methods for achieving the best results.
To learn a little more you can check out the info page with links to contributors and further info. You can also submit your own resource ideas by sending a quick tweet to @WebFieldManual.
This site has the opportunity to grow much faster than other resources based on user submission. It already has an amazing collection of hand-curated links for designers & developers with many more on the way.
Many posts and guides have been published online with a direct focus on web design & user experience. These resources have ultimately become scattered but still operate as serious tools for anyone who builds interfaces on the web or on mobile devices.
A brand new website named The Web Field Manual attempts to collect as many resources together in one location.
The site is meant to be a collection of tools, best practices, tips, reference links, and so many detailed topics related to design & development. Web Field Manual has an individual page for coding topics like CSS, SVG, and JavaScript.
Every person who works to craft interfaces from designers to developers could learn something from this website. It’s ultimately geared towards anyone who wants to learn more about the industry with a focus on the highest-rated methods for achieving the best results.
To learn a little more you can check out the info page with links to contributors and further info. You can also submit your own resource ideas by sending a quick tweet to @WebFieldManual.
This site has the opportunity to grow much faster than other resources based on user submission. It already has an amazing collection of hand-curated links for designers & developers with many more on the way.
The purpose of a lazy-loading script is to speed up a website’s performance without pushing extra HTTP requests through a full page refresh. The goal is to save bandwidth on visitors who may never scroll down far enough to see the freshly-loaded images.
Although lazy-load features can apply to pagination, many developers opt towards lazy-loading images since it’s an easier task with immediate benefits.
bLazy.js(or beLazy.js) is the perfect script for handling lazy image loading. It runs on pure JavaScript without any dependencies and only requires a small amount of code to build into a functioning product.
To see it in action check out the live demo page with a long stream of lazy-loaded images. You’ll also find sample code snippets with instructions on how to set this up for your own website.
The entire bLazy.js script is completely free to download, use, and edit to your own accord. It functions in all modern browsers and is even supported by Microsoft’s IE7+.
It only requires a single file and this can be minified down to ~1KB in size. If you have lots of images on any given page then I can assume this script would end up saving you much more than 1KB per pageload.
To try it out simply download a copy from the GitHub repo and see how it fares. You’ll find all the documentation and demo links right on GitHub so you shouldn’t need to go far to get bLazy.js up & running smoothly.
The purpose of a lazy-loading script is to speed up a website’s performance without pushing extra HTTP requests through a full page refresh. The goal is to save bandwidth on visitors who may never scroll down far enough to see the freshly-loaded images.
Although lazy-load features can apply to pagination, many developers opt towards lazy-loading images since it’s an easier task with immediate benefits.
bLazy.js(or beLazy.js) is the perfect script for handling lazy image loading. It runs on pure JavaScript without any dependencies and only requires a small amount of code to build into a functioning product.
To see it in action check out the live demo page with a long stream of lazy-loaded images. You’ll also find sample code snippets with instructions on how to set this up for your own website.
The entire bLazy.js script is completely free to download, use, and edit to your own accord. It functions in all modern browsers and is even supported by Microsoft’s IE7+.
It only requires a single file and this can be minified down to ~1KB in size. If you have lots of images on any given page then I can assume this script would end up saving you much more than 1KB per pageload.
To try it out simply download a copy from the GitHub repo and see how it fares. You’ll find all the documentation and demo links right on GitHub so you shouldn’t need to go far to get bLazy.js up & running smoothly.
In April 2015, our team of engineers and tech evangelists at Microsoft launched Vorlon.js — an open source, extensible, platform-agnostic tool for remotely debugging and testing your JavaScript. When we launched the project during the Microsoft Build Developer Conference keynote, we had only three plugins: the DOM Explorer, the Interactive Console and Modernizr. We knew at this time that the key to the success for a project such as Vorlon is the quantity and quality of plugins. When you want to debug your website, you do not want to do much complicated things. You just want to pick the correct plugin and get the correct information. This is why we made this project open source. We know you have a lot of ideas to provide great debug experiences to web developers. So… 2 months, 66 pull requests, 78 issues and 547 commits later: we are proud to announce that we (YOU and the team) just released Vorlon.js version 0.0.15! You can get it by either cloning our GitHub repository or installing it using npmcommand tool (npm install –g vorlon). Note: if you are still wondering what Vorlon.js is, please read this article from David Catuhe first. Let’s have a look at […]
* You might also be interested in the following articles
A few old men working for Walt Disney back in the early 20th century came up with a dozen working properties for lifelike animation. These “12 principles of animation” have lasted for decades and continue to hold a major influence over the animation industry.
It’s only in recent years that we’ve seen animation play a serious role in regards to interface design & user experience. Designers are using tools like Adobe After Effects to bring interfaces to life. When first getting started this can be a daunting task, especially to someone with no background in animation.
Thankfully the digital world makes this a lot easier, and the Internet makes learning a no-brainier.
So what are these 12 principles? They represent how you should animate objects(or people, animals, etc) to behave in “expected” ways that feel more lifelike to the viewer. In real life we know that humans animate in a certain way. But we also know that buttons, keys, and movable objects behave in their own unique ways.
If you’re interested to learn more UI/UX animation then this video is a great place to start. You’ll come to understand the raw fundamentals of animation which will help you plan out your decisions much more carefully.
To build your own backend e-mail script requires some understanding of a programming language like PHP or RoR. It’s not exactly hard, but for a newbie it’s not exactly easy either.
Often times developers rely on pre-built scripts made for sending SMTP e-mails. These can work great but also require some complications when it comes to error handling & file uploads.
Now there’s an even easier way to go using the MailThis webapp. It’s a completely free tool which takes requests from any HTML form and converts all the data into a lovely e-mail.
You simply code up an HTML form on the frontend and set it to POST submission. The action attribute should point towards MailThis following the syntax http://mailthis.to/you@mail.com. When the user submits a form it’ll go through MailThis where everything gets processed & e-mailed directly to your inbox.
There’s no need for any backend development or complicated libraries on your server. The entire backend submission process is handled through MailThis without any complications.
If you’re curious check out the documentation page for more info. This page covers everything you’d need to setup special HTML header info like reply-to data.
There’s no denying that many developers would rather keep everything local on their own server. But if you’re curious to try new web applications it seems MailThis could be an excellent way to go for simple mailing features – no backend knowledge required.
The ever-growing market for sports content has only strengthened through support over the Internet. Online interactive communities like forums or fantasy football leagues provide a digital connection to the real world. Nevermind the ability to track game scores, player stats, and a whole lot of other statistical information.
In this gallery I’ve put together 33 inspiring sports-related websites. Each design caters to the website’s content ranging from professional athletes, sports teams, television networks, mobile apps, and obviously sporting events. If you’re currently on a project or just need some sporty inspiration then try drafting a few of these design trends into your own creative work.
The following is a guest post by Steven Estrella. Steven shared with me a technique for creating customized range inputs by writing a little JavaScript atop some of the techniques explored here by Daniel Stern and others. I invited Steven to explain his approach.
Last year, Daniel Stern wrote a very useful article to demonstrate cross-browser styling of the HTML5 range input using nothing more than CSS and HTML. He even created a handy tool called range.css for generating the CSS. Sometimes, however, our designs may need to go beyond what is possible with CSS alone.
In the example below I wanted to experiment with what’s currently possible when manipulating a range input with JavaScript:
Notice how the track fills with a gradient as you drag the thumb? Also, the thumb uses an image as its background, rotates whilst you drag, and displays the value as text. And of course there is the not-so-small-matter of allowing for both horizontal or vertical slider orientations and preserving inputs from the keyboard too. We’ll go into further detail on that soon. Ultimately, this tutorial will walk you through the code and concepts to add this type of control over the appearance and functionality of HTML5 range inputs.
Marking things up
To get started, we’ll make the standard range input invisible to the user, place it on top of our own styled divs, and then wire them all together with a few lines of JavaScript. The user will then drag the invisible range input thumb, which will fire event listeners that call a function and transmit the range input value. Consequently, this will trigger changes to the appearance of the styled divs.
The outer .slidershell div exists to provide a positioning context for the divs it contains.
.sliderfill should create a gradient that changes the appearance as the user drags the thumb.
.slidertrack will display a styled border on top of the .sliderfill.
.sliderthumb makes the 90’s-style beveled square image that looks like marble.
.slidervalue styles the current value of the slider input.
Finally, the is added last so that it rests on top of those other elements.
In our example we’ll need to have three of these td elements, with each input having an id attribute with a different number at the end. This will allow us to present multiple sliders in both orientations on the same page. At the moment our input will look like this:
Next, we can add an inline event listener to call a JavaScript function when the slider has an input or registers a change in the value. The function should take three parameters: the value of the slider, the number of the slider, and a boolean value of true if the slider should be vertical. We’ll call this function showValue():
Now we have to strip away the default appearance of the range input with some CSS that effectively acts as a reset. We can do this by first adapting the ideas presented by Daniel Stern, but then focus our efforts on making all the default elements of the range input appear transparent.
/* First we have to make transparent all the default elements of the range input. We use color:transparent to eliminate the default tick marks in IE. */
input[type=range]::-ms-track {
width: 100%;
height: 100%;
-webkit-appearance: none;
margin: 0px;
padding: 0px;
border: 0 none;
background: transparent;
color: transparent;
overflow: visible;
}
input[type=range]::-moz-range-track {
width: 100%;
height: 100%;
-moz-appearance: none;
margin: 0px;
padding: 0px;
border: 0 none;
background: transparent;
color: transparent;
overflow: visible;
}
input[type=range] {
width: 100%;
height: 100%;
-webkit-appearance: none;
margin: 0px;
padding: 0px;
border: 0 none;
background: transparent;
color: transparent;
overflow: visible;
}
input[type=range]:focus::-webkit-slider-runnable-track {
background: transparent;
border: transparent;
}
input[type=range]:focus {
outline: none;
}
/* Make the thumbs the same size as your custom sliderthumb. They will not be visible but they will be draggable. */
input[type=range]::-ms-thumb {
width: 40px;
height: 40px;
border-radius: 0px;
border: 0 none;
background: transparent;
}
input[type=range]::-moz-range-thumb {
width: 40px;
height: 40px;
border-radius: 0px;
border: 0 none;
background: transparent;
}
input[type=range]::-webkit-slider-thumb {
width: 40px;
height: 40px;
border-radius: 0px;
border: 0 none;
background: transparent;
-webkit-appearance: none;
}
/* Eliminate the default appearance and tooltip behaviour that is peculiar to IE and Edge. */
input[type=range]::-ms-fill-lower {
background: transparent;
border: 0 none;
}
input[type=range]::-ms-fill-upper {
background: transparent;
border: 0 none;
}
input[type=range]::-ms-tooltip {
display: none;
}
At this point, if you reload your example, you’ll find that the default range elements will now be hidden. Notice also that the width and height are set to 100% of its containing element (the .slidershell class in our example). However, the CSS for the thumb pseudo-elements requires us to enter a specific width and height in pixels. These dimensions should match the size of whatever image you plan to use for the thumb because we must ensure that the draggable area of the invisible range input matches the size of the visible thumb image.
Next, we can choose an image to use for the draggable thumb. I selected an old 90s-style library image of a green marble beveled square:
Following this, we can style our customized range input to look however we’d like:
/* The .slider and .slidervertical classes are for the range inputs. Set the z-index high so its on top. */
.slider,
.slidervertical {
position: absolute;
left: 0;
top: 0;
overflow: visible;
z-index: 100;
}
/* slidershell exists only to provide a positioning context for the range input and other elements.*/
.slidershell {
border: 0 none;
position: relative;
left: 0;
top: 0;
overflow: visible;
}
/* .slidertrack is the visible track on which the user drags the thumb button. */
.slidertrack {
border: 2px outset #666;
border-radius: 4px;
position: absolute;
}
/* .sliderfill adds color (or a gradient as seen here) to the track as the user drags the thumb. */
.sliderfill {
border: 2px solid #00767f;
border-radius: 4px;
position: absolute;
opacity: 0.2;
pointer-events: none;
background: #00767f;
background: linear-gradient(90deg, #005555, #006699);
}
/* .sliderthumb can be any css you like including an image.
The dimensions must match those found in the rule for
input[type=range]::-webkit-slider-thumb. */
.sliderthumb {
width: 40px;
height: 40px;
background-image: url('thumb.png');
background-size: 40px 40px;
background-position: 0px 0px;
background-repeat: no-repeat;
background-color: transparent;
position: absolute;
left: 0;
top: 0;
border: 0 none;
padding: 0;
margin: 0;
text-align: center;
pointer-events: none;
}
/* .slidervalue can be styled as you see fit */
.slidervalue {
width: 40px;
height: 40px;
line-height: 40px;
color: #fff;
font-family: sans-serif;
font-size: 18px;
position: absolute;
left: 0;
top: 0;
border: 0 none;
padding: 0;
margin: 0;
text-align: center;
pointer-events: none;
}
Finally, we can tie everything together with JavaScript. The showValue function receives a parameter representing the value chosen in the range element and a second parameter representing the slider number. The third parameter is a boolean to indicate vertical orientation if true. We can have as many sliders as we want on one page, all we need to do is give them each a serialized id (#sliderthumb1, #sliderthumb2, etc.). Then, with some simple math, we can use the value to locate and rotate the thumb, display the value as text, and fill the track with color as the user drags the thumb. A series of inline if structures allows us to support vertical orientation when requested. I also included a setValue() function you can use to set the values of your sliders when the page loads.
/* We need to change slider appearance oninput and onchange */
function showValue(val,slidernum,vertical) {
/* setup variables for the elements of our slider */
var thumb = document.getElementById("sliderthumb" + slidernum);
var shell = document.getElementById("slidershell" + slidernum);
var track = document.getElementById("slidertrack" + slidernum);
var fill = document.getElementById("sliderfill" + slidernum);
var rangevalue = document.getElementById("slidervalue" + slidernum);
var slider = document.getElementById("slider" + slidernum);
var pc = val/(slider.max - slider.min); /* the percentage slider value */
var thumbsize = 40; /* must match the thumb size in your css */
var bigval = 250; /* widest or tallest value depending on orientation */
var smallval = 40; /* narrowest or shortest value depending on orientation */
var tracksize = bigval - thumbsize;
var fillsize = 16;
var filloffset = 10;
var bordersize = 2;
var loc = vertical ? (1 - pc) * tracksize : pc * tracksize;
var degrees = 360 * pc;
var rotation = "rotate(" + degrees + "deg)";
rangevalue.innerHTML = val;
thumb.style.webkitTransform = rotation;
thumb.style.MozTransform = rotation;
thumb.style.msTransform = rotation;
fill.style.opacity = pc + 0.2 > 1 ? 1 : pc + 0.2;
rangevalue.style.top = (vertical ? loc : 0) + "px";
rangevalue.style.left = (vertical ? 0 : loc) + "px";
thumb.style.top = (vertical ? loc : 0) + "px";
thumb.style.left = (vertical ? 0 : loc) + "px";
fill.style.top = (vertical ? loc + (thumbsize/2) : filloffset + bordersize) + "px";
fill.style.left = (vertical ? filloffset + bordersize : 0) + "px";
fill.style.width = (vertical ? fillsize : loc + (thumbsize/2)) + "px";
fill.style.height = (vertical ? bigval - filloffset - fillsize - loc : fillsize) + "px";
shell.style.height = (vertical ? bigval : smallval) + "px";
shell.style.width = (vertical ? smallval : bigval) + "px";
track.style.height = (vertical ? bigval - 4 : fillsize) + "px"; /* adjust for border */
track.style.width = (vertical ? fillsize : bigval - 4) + "px"; /* adjust for border */
track.style.left = (vertical ? filloffset + bordersize : 0) + "px";
track.style.top = (vertical ? 0 : filloffset + bordersize) + "px";
}
/* we often need a function to set the slider values on page load */
function setValue(val,num,vertical) {
document.getElementById("slider"+num).value = val;
showValue(val,num,vertical);
}
Making vertical inputs
To make those vertical inputs we mentioned earlier we can set the third parameter of the showValue() function to true and add orient="vertical" to the input itself, like so:
The orient="vertical" attribute is only supported by Firefox, so to fix this we’ll need to update our CSS:
/* we need a separate rule for when the range input is to be vertical */
input[type=range].slidervertical {
-webkit-appearance: slider-vertical;
writing-mode: bt-lr; /* IE */
opacity:0.01; /* needed to hide the default slider-vertical appearance */
}
Because we have to use -webkit-appearance: slider-vertical, we have to set the opacity to 0.01 here to keep the vertical slider invisible. And here’s what that additional markup and CSS will look like:
For the longest time styling inputs was beyond challenging. But now, with a little CSS and JavaScript, we can fix these problems in all modern browsers without the heroic efforts required in the past.
