Skip navigation
Help

paint

warning: Creating default object from empty value in /var/www/vhosts/sayforward.com/subdomains/recorder/httpdocs/modules/taxonomy/taxonomy.pages.inc on line 33.

The Dying Art of Belly Dancing in Conservative Egypt<br />
At the Scheherezade club in Cairo’s downtown district, five paying customers and a dozen staff sat and gawped as the belly dancer shimmied across the stage, amid the peeling paint, chipped murals and dusty faux chandeliers of what used to be a very grand dance hall. The atmosphere is awkward and sad. When a member of the audience threw a handful of Egyptian pounds in the air, the club owner swiftly appeared and scooped it all up. When someone tucked a big bill into the dancer’s dress, she promptly handed it over to the aging pimp-like crooner on stage.<br />
There’s no glitz or glamor in sight, only a tired and depressed-looking dancer doing one of the few things that might earn an uneducated woman a lot of money in Egypt. (Top dancers can earn up to $2000 to perform at a wedding.)<br />
The past three years have been tough in general for most Cairo entertainers.<br />
Continue

The Dying Art of Belly Dancing in Conservative Egypt

At the Scheherezade club in Cairo’s downtown district, five paying customers and a dozen staff sat and gawped as the belly dancer shimmied across the stage, amid the peeling paint, chipped murals and dusty faux chandeliers of what used to be a very grand dance hall. The atmosphere is awkward and sad. When a member of the audience threw a handful of Egyptian pounds in the air, the club owner swiftly appeared and scooped it all up. When someone tucked a big bill into the dancer’s dress, she promptly handed it over to the aging pimp-like crooner on stage.

There’s no glitz or glamor in sight, only a tired and depressed-looking dancer doing one of the few things that might earn an uneducated woman a lot of money in Egypt. (Top dancers can earn up to $2000 to perform at a wedding.)

The past three years have been tough in general for most Cairo entertainers.

Continue

0
Your rating: None

If you're a fan of witty t-shirts, you might already be obsessed with Threadless, a site that combines e-commerce with community.

Here's how Threadless works: Absolutely anyone can submit a shirt design that features absolutely anything. New designs are posted each week and the site's 2.5 million community members vote on which they like best. The most popular shirts get printed and the artist receives $2,000, $500 in Threadless gift cards, and royalties from the sales of their shirt. 

0
Your rating: None
Original author: 
Addy Osmani

  

Today we’ll discuss how to improve the paint performance of your websites and Web apps. This is an area that we Web developers have only recently started looking at more closely, and it’s important because it could have an impact on your user engagement and user experience.

Frame Rate Applies To The Web, Too

Frame rate is the rate at which a device produces consecutive images to the screen. A low frames per second (FPS) means that individual frames can be made out by the eye. A high FPS gives users a more responsive feel. You’re probably used to this concept from the world of gaming, but it applies to the Web, too.

Long image decoding, unnecessary image resizing, heavy animation and data processing can all lead to dropped frames, which reduces the frame rate, resulting in janky pages. We’ll explain what exactly we mean by “jank” shortly.

Why Care About Frame Rate?

Smooth, high frame rates drive user engagement and can affect how much users interact with your website or app.

At EdgeConf earlier this year, Facebook confirmed this when it mentioned that in an A/B test, it slowed down scrolling from 60 FPS to 30 FPS, causing engagement to collapse. That said, if you can’t do high frame rates and 60 FPS is out of reach, then you’d at least want something smooth. If you’re doing your own animation, this is one benefit of using requestAnimationFrame: the browser can dynamically adjust to keep the frame rate normal.

In cases where you’re concerned about scrolling, the browser can manage the frame rate for you. But if you introduce a large amount of jank, then it won’t be able to do as good a job. So, try to avoid big hitches, such as long paints, long JavaScript execution times, long anything.

Don’t Guess It, Test It!

Before getting started, we need to step back and look at our approach. We all want our websites and apps to run more quickly. In fact, we’re arguably paid to write code that runs not only correctly, but quickly. As busy developers with deadlines, we find it very easy to rely on snippets of advice that we’ve read or heard. Problems arise when we do that, though, because the internals of browsers change very rapidly, and something that’s slow today could be quick tomorrow.

Another point to remember is that your app or website is unique, and, therefore, the performance issues you face will depend heavily on what you’re building. Optimizing a game is a very different beast to optimizing an app that users will have open for 200+ hours. If it’s a game, then you’ll likely need to focus your attention on the main loop and heavily optimize the chunk of code that is going to run every frame. With a DOM-heavy application, the memory usage might be the biggest performance bottleneck.

Your best option is to learn how to measure your application and understand what the code is doing. That way, when browsers change, you will still be clear about what matters to you and your team and will be able to make informed decisions. So, no matter what, don’t guess it, test it!

We’re going to discuss how to measure frame rate and paint performance shortly, so hold onto your seats!

Note: Some of the tools mentioned in this article require Chrome Canary, with the “Developer Tools experiments” enabled in about:flags. (We — Addy Osmani and Paul Lewis — are engineers on the Developer Relations team at Chrome.)

Case Study: Pinterest

The other day we were on Pinterest, trying to find some ponies to add to our pony board (Addy loves ponies!). So, we went over to the Pinterest feed and started scrolling through, looking for some ponies to add.

Screen Shot 2013-03-25 at 14.30.57-500
Addy adding some ponies to his Pinterest board, as one does. Larger view.

Jank Affects User Experience

The first thing we noticed as we scrolled was that scrolling on this page doesn’t perform very well — scrolling up and down takes effort, and the experience just feels sluggish. When they come up against this, users get frustrated, which means they’re more likely to leave. Of course, this is the last thing we want them to do!

Screen Shot 2013-03-25 at 14.31.27-500
Pinterest showing a performance bottleneck when a user scrolls. Larger view.

This break in consistent frame rate is something the Chrome team calls “jank,” and we’re not sure what’s causing it here. You can actually notice some of the frames being drawn as we scroll. But let’s visualize it! We’re going to open up Frames mode and show what slow looks like there in just a moment.

Note: What we’re really looking for is a consistently high FPS, ideally matching the refresh rate of the screen. In many cases, this will be 60 FPS, but it’s not guaranteed, so check the devices you’re targeting.

Now, as JavaScript developers, our first instinct is to suspect a memory leak as being the cause. Perhaps some objects are being held around after a round of garbage collection. The reality, however, is that very often these days JavaScript is not a bottleneck. Our major performance problems come down to slow painting and rendering times. The DOM needs to be turned into pixels on the screen, and a lot of paint work when the user scrolls could result in a lot of slowing down.

Note: HTML5 Rocks specifically discusses some of the causes of slow scrolling. If you think you’re running into this problem, it’s worth a read.

Measuring Paint Performance

Frame Rate

We suspect that something on this page is affecting the frame rate. So, let’s go open up Chrome’s Developer Tools and head to the “Timeline” and “Frames” mode to record a new session. We’ll click the record button and start scrolling the page the way a normal user would. Now, to simulate a few minutes of usage, we’re going to scroll just a little faster.

Screen Shot 2013-05-15 at 17.57.48-500
Using Chrome’s Developer Tools to profile scrolling interactions. Larger view.

Up, down, up, down. What you’ll notice now in the summary view up at the top is a lot of purple and green, corresponding to painting and rendering times. Let’s stop recording for now. As we flip through these various frames, we see some pretty hefty “Recalculate Styles” and a lot of “Layout.”

If you look at the legend to the very right, you’ll see that we’ve actually blown our budget of 60 FPS, and we’re not even hitting 30 FPS either in many cases. It’s just performing quite poorly. Now, each of these bars in the summary view correspond to one frame — i.e. all of the work that Chrome has to do in order to be able to draw an app to the screen.

screen434343-500
Chrome’s Developer Tools showing a long paint time. Larger view.

Frame Budget

If you’re targeting 60 FPS, which is generally the optimal number of frames to target these days, then to match the refresh rate of the devices we commonly use, you’ll have a 16.7-millisecond budget in which to complete everything — JavaScript, layout, image decoding and resizing, painting, compositing — everything.

Note: A constant frame rate is our ideal here. If you can’t hit 60 FPS for whatever reason, then you’re likely better off targeting 30 FPS, rather than allowing a variable frame rate between 30 and 60 FPS. In practice, this can be challenging to code because when the JavaScript finishes executing, all of the layout, paint and compositing work still has to be done, and predicting that ahead of time is very difficult. In any case, whatever your frame rate, ensure that it is consistent and doesn’t fluctuate (which would appear as stuttering).

If you’re aiming for low-end devices, such as mobile phones, then that frame budget of 16 milliseconds is really more like 8 to 10 milliseconds. This could be true on desktop as well, where your frame budget might be lowered as a result of miscellaneous browser processes. If you blow this budget, you will miss frames and see jank on the page. So, you likely have somewhere nearer 8 to 10 milliseconds, but be sure to test the devices you’re supporting to get a realistic idea of your budget.

Screen Shot 2013-03-25 at 14.34.26-500
An extremely costly layout operation of over 500 milliseconds. Larger view.

Note: We’ve also got an article on how to use the Chrome Developer Tools to find and fix rendering performance issues that focuses more on the timeline.

Going back to scrolling, we have a sneaking suspicion that a number of unnecessary repaints are occurring on this page with onscroll.

One common mistake is to stuff just way too much JavaScript into the onscroll handlers of a page — making it difficult to meet the frame budget at all. Aligning the work to the rendering pipeline (for example, by placing it in requestAnimationFrame) gives you a little more headroom, but you still have only those few milliseconds in which to get everything done.

The best thing you can do is just capture values such as scrollTop in your scroll handlers, and then use the most recent value inside a requestAnimationFrame callback.

Paint Rectangles

Let’s go back to Developer Tools → Settings and enable “Show paint rectangles.” This visualizes the areas of the screen that are being painted with a nice red highlight. Now look at what happens as we scroll through Pinterest.

Screen Shot 2013-03-25 at 14.35.17-500
Enabling Chrome Developer Tools’ “Paint Rectangles” feature. Larger view.

Every few milliseconds, we experience a big bright flash of red across the entire screen. There seems to be a paint of the whole screen every time we scroll, which is potentially very expensive. What we want to see is the browser just painting what is new to the page — so, typically just the bottom or top of the page as it gets scrolled into view. The cause of this issue seems to be the little “scroll to top” button in the lower-right corner. As the user scrolls, the fixed header at the top needs to be repainted, but so does the button. The way that Chrome deals with this is to create a union of the two areas that need to be repainted.

Screen Shot 2013-05-15 at 19.00.12-500
Chrome shows freshly painted areas with a red box. Larger view.

In this case, there is a rectangle from the top left to top right, but not very tall, plus a rectangle in the lower-right corner. This leaves us with a rectangle from the top left to bottom right, which is essentially the whole screen! If you inspect the button element in Developer Tools and either hide it (using the H key) or delete it and then scroll again, you will see that only the header area is repainted. The way to solve this particular problem is to move the scroll button to its own layer so that it doesn’t get unioned with the header. This essentially isolates the button so that it can be composited on top of the rest of the page. But we’ll talk about layers and compositing in more detail in a little bit.

The next thing we notice has to do with hovering. When we hover over a pin, Pinterest paints an action bar containing “Repin, comment and like” buttons — let’s call this the action bar. When we hover over a single pin, it paints not just the bar but also the elements underlying it. Painting should happen only on those elements that you expect to change visually.

Screen Shot 2013-03-25 at 14.35.46-500
A cause for concern: full-screen flashes of red indicate a lot of painting. Larger view.

There’s another interesting thing about scrolling here. Let’s keep our cursor hovered over this pin and start scrolling the page again.

Every time we scroll through a new row of images, this action bar gets painted on yet another pin, even though we don’t mean to hover over it. This comes down more to UX than anything else, but scrolling performance in this case might be more important than the hover effect during scrolling. Hovering amplifies jank during scrolling because the browser essentially pauses to go off and paint the effect (the same is true when we roll out of the element!). One option here is to use a setTimeout with a delay to ensure that the bar is painted only when the user really intends to use it, an approach we covered in “Avoiding Unnecessary Paints.” A more aggressive approach would be to measure the mouseenter or the mouse’s trajectory before enabling hover behaviors. While this measure might seem rather extreme, remember that we are trying to avoid unnecessary paints at all costs, especially when the user is scrolling.

Overall Paint Cost

We now have a really great workflow for looking at the overall cost of painting on a page; go back into Developer Tools and “Enable continuous page repainting.” This feature will constantly paint to your screen so that you can find out what elements have costly paint times. You’ll get this really nice black box in the top corner that summarizes paint times, with the minimum and maximum also displayed.

screenshot43234242-500
Chrome’s “Continuous Page Repainting” mode helps you to assess the overall cost of a page. Larger view.

Let’s head back to the “Elements” panel. Here, we can select a node and just use the keyboard to walk the DOM tree. If we suspect that an element has an expensive paint, we can use the H shortcut key (something recently added to Chrome) to toggle visibility on that element. Using the continuous paint box, we can instantly see whether this has a positive effect on our pages’ paint times. We should expect it to in many cases, because if we hide an element, we should expect a corresponding reduction in paint times. But by doing this, we might see one element that is especially expensive, which would bear further scrutiny!

Screen Shot 2013-06-10 at 09.46.31_500_mini
The “Continuous Page Repainting” chart showing the time taken to paint the page.

For Pinterest’s website, we can do it to the categories bar or to the header, and, as you’d expect, because we don’t have to paint these elements at all, we see a drop in the time it takes to paint to the screen. If we want even more detailed insight, we can go right back to the timeline and record a new session to measure the impact. Isn’t that great? Now, while this workflow should work great for most pages, there might be times when it isn’t as useful. In Pinterest’s case, the pins are actually quite deeply nested in the page, making it hard for us to measure paint times in this workflow.

Luckily, we can still get some good mileage by selecting an element (such as a pin here), going to the “Styles” panel and looking at what CSS styles are being used. We can toggle properties on and off to see how they effect the paint times. This gives us much finer-grained insight into the paint profile of the page.

Here, we see that Pinterest is using box-shadow on these pins. We’ve optimized the performance of box-shadow in Chrome over the past two years, but in combination with other styles and when heavily used, it could cause a bottleneck, so it’s worth looking at.

Pinterest has reduced continuous paint mode times by 40% by moving box-shadow to a separate element that doesn’t have border-radius. The side effect is slightly fuzzy-looking corners; however, it is barely noticeable due to the color scheme and the low border-radius values.

Note: You can read more about this topic in “CSS Paint Times and Page Render Weight.”

Screen Shot 2013-03-25 at 15.47.40-500
Toggling styles to measure their effect on page-rendering weight. Larger view.

Let’s disable box-shadow to see whether it makes a difference. As you can see, it’s no longer visible on any of the pins. So, let’s go back to the timeline and record a new session in which we scroll the same way as we did before (up and down, up and down, up and down). We’re getting closer to 60 FPS now, and that’s just from one change.

Public service announcement: We’re absolutely not saying don’t use box-shadow — by all means, do! Just make sure that if you have a performance problem, measure correctly to find out what your own bottlenecks are. Always measure! Your website or application is unique, as will any performance bottleneck be. Browser internals change almost daily, so measuring is the smartest way to stay up to date on the changes, and Chrome’s Developer Tools makes this really easy to do.

Screen Shot 2013-03-25 at 15.50.25-500
Using Chrome Developer Tools to profile is the best way to track browser performance changes. Larger view.

Note: Eberhard Grather recently wrote a detailed post on “Profiling Long Paint Times With DevTools’ Continuous Painting Mode,” which you should spend some quality time with.

Another thing we noticed is that if you click on the “Repin” button, do you see the animated effect and the lightbox being painted? There’s a big red flash of repaint in the background. It’s not clear from the tooling if the paint is the white cover or some other affected being area. Be sure to double check that the paint rectangles correspond to the element or elements that you think are being repainted, and not just what it looks like. In this case, it looks like the whole screen is being repainted, but it could well be just the white cover, which might not be all that expensive. It’s nuanced; the important thing is to understand what you’re seeing and why.

Hardware Compositing (GPU Acceleration)

The last thing we’re going to look at on Pinterest is GPU acceleration. In the past, Web browsers have relied pretty heavily on the CPU to render pages. This involved two things: firstly, painting elements into a bunch of textures, called layers; and secondly, compositing all of those layers together to the final picture seen on screen.

Over the past few years, however, we’ve found that getting the GPU involved in the compositing process can lead to some significant speeding up. The premise is that, while the textures are still painted on the CPU, they can be uploaded to the GPU for compositing. Assuming that all we do on future frames is move elements around (using CSS transitions or animations) or change their opacity, we simply provide these changes to the GPU and it takes care of the rest. We essentially avoid having to give the GPU any new graphics; rather, we just ask it to move existing ones around. This is something that the GPU is exceptionally quick at doing, thus improving performance overall.

There is no guarantee that this hardware compositing will be available and enabled on a given platform, but if it is available the first time you use, say, a 3D transform on an element, then it will be enabled in Chrome. Many developers use the translateZ hack to do just that. The other side effect of using this hack is that the element in question will get its own layer, which may or may not be what you want. It can be very useful to effectively isolate an element so that it doesn’t affect others as and when it gets repainted. It’s worth remembering that the uploading of these textures from system memory to the video memory is not necessarily very quick. The more layers you have, the more textures need to be uploaded and the more layers that will need to be managed, so it’s best not to overdo it.

Note: Tom Wiltzius has written about the layer model in Chrome, which is a relevant read if you are interested in understanding how compositing works behind the scenes. Paul has also written a post about the translateZ hack and how to make sure you’re using it in the right ways.

Another great setting in Developer Tools that can help here is “Show composited layer borders.” This feature will give you insight into those DOM elements that are being manipulated at the GPU level.

layer_folders_addy_500_mini
Switching on composited layer borders will indicate Chrome’s rendering layers. Larger view.

If an element is taking advantage of the GPU acceleration, you’ll see an orange border around it with this on. Now as we scroll through, we don’t really see any use of composited layers on this page — not when we click “Scroll to top” or otherwise.

Chrome is getting better at automatically handling layer promotion in the background; but, as mentioned, developers sometimes use the translateZ hack to create a composited layer. Below is Pinterest’s feed with translateZ(0) applied to all pins. It’s not hitting 60 FPS, but it is getting closer to a consistent 30 FPS on desktop, which is actually not bad.

Screen Shot 2013-05-15 at 19.03.13-500
Using the translateZ(0) hack on all Pinterest pins. Note the orange borders. Larger view.

Remember to test on both desktop and mobile, though; their performance characteristics vary wildly. Use the timeline in both, and watch your paint time chart in Continuous Paint mode to evaluate how fast you’re busting your budget.

Again, don’t use this hack on every element on the page — it might pass muster on desktop, but it won’t on mobile. The reason is that there is increased video memory usage and an increased layer management cost, both of which could have a negative impact on performance. Instead, use hardware compositing only to isolate elements where the paint cost is measurably high.

Note: In the WebKit nightlies, the Web Inspector now also gives you the reasons for layers being composited. To enable this, switch off the “Use WebKit Web Inspector” option and you’ll get the front end with this feature in there. Switch it on using the “Layers” button.

A Find-and-Fix Workflow

Now that we’ve concluded our Pinterest case study, what about the workflow for diagnosing and addressing your own paint problems?

Finding the Problem

  • Make sure you’re in “Incognito” mode. Extensions and apps can skew the figures that are reported when profiling performance.
  • Open the page and the Developer Tools.
  • In the timeline, record and interact with your page.
  • Check for frames that go over budget (i.e. over 60 FPS).
  • If you’re close to budget, then you’re likely way over the budget on mobile.
  • Check the cause of the jank. Long paint? CSS layout? JavaScript?

Screen Shot 2013-05-15 at 19.36.22-500
Spend some quality time with Frame mode in Chrome Developer Tools to understand your website’s runtime profile. Larger view.

Fixing the Problem

  • Go to “Settings” and enable “Continuous Page Repainting.”
  • In the “Elements” panel, hide anything non-essential using the hide (H) shortcut.
  • Walk through the DOM tree, hiding elements and checking the FPS in the timeline.
  • See which element(s) are causing long paints.
  • Uncheck styles that could affect paint time, and track the FPS.
  • Continue until you’ve located the elements and styles responsible for the slow-down.

fixing-500_mini
Switch on extra Developer Tools features for more insight. Larger view.

What About Other Browsers?

Although at the time of writing, Chrome has the best tools to profile paint performance, we strongly recommend testing and measuring your pages in other browsers to get a feel for what your own users might experience (where feasible). Performance can vary massively between them, and a performance smell in one browser might not be present in another.

As we said earlier, don’t guess it, test it! Measure for yourself, understand the abstractions, know your browser’s internals. In time, we hope that the cross- browser tooling for this area improves so that developers can get an accurate picture of rendering performance, regardless of the browser being used.

Conclusion

Performance is important. Not all machines are created equal, and the fast machines that developers work on might not have the performance problems encountered on the devices of real users. Frame rate in particular can have a big impact on engagement and, consequently, on a project’s success. Luckily, a lot of great tools out there can help with that.

Be sure to measure paint performance on both desktop and mobile. If all goes well, your users will end up with snappier, more silky-smooth experiences, regardless of the device they’re using.

Further Reading

About the Authors

Addy Osmani and Paul Lewis are engineers on the Developer Relations team at Chrome, with a focus on tooling and rendering performance, respectively. When they’re not causing trouble, they have a passion for helping developers build snappy, fluid experiences on the Web.

(al)

© Addy Osmani for Smashing Magazine, 2013.

0
Your rating: None
Original author: 
WSJ Staff

William Eggleston's photographs, some of which are on display now at The Met Museum in New York, reminds us why he an American master. Though not a fan of digital photography, Mr. Eggleston agreed to shoot a digital photo for the upcoming June issue of WSJ. Magazine. Get a preview of that photo here.

0
Your rating: None
Original author: 
burn magazine

This SlideShowPro photo gallery requires the Flash Player plugin and a web browser with JavaScript enabled.

Hover over the image for navigation and full screen controls
ESSAY CONTAINS EXPLICIT CONTENT

Zaida González Ríos

Primera Comunión

play this essay

 

My intention is to critique the traditions and social references of Western culture, as well as use irony in questioning certain canons, such as the idealization of the body in advertising and media, the role of gender, and a consumer based existence due to globalization and individualism in an environment that is marked by an increase in the disposable.

I seek to show something different: that which is not well regarded or accepted, an escape from what we have been taught to “behold and admire.” This is manifested with ordinary models, average people who would not otherwise be photographed for an advertising campaign.

With the inclusion of dead and deformed babies in the photographs, I intend to rescue people that were abandoned without a proper farewell. I want to dignify them, transporting them into a picture, surrounded by objects and symbolism to leave them history so that they do not go unnoticed or ignored. I confront the viewer with the truth, one that weighs on the conscience of agricultural industries, since the indiscriminate use of toxic pesticides every year cause children to be born with and die from physiological and physical deformities. This fact is hidden from society by companies that have economic power in our country.

With the lighting techniques used in the images (black and white pictures painted by hand) and small format, I intend to create a break between the form and substance, softening and dislodging the message.

 

Bio

1977, San Miguel, Santiago de Chile.

Photographer and veterinarian.

Zaida received her degree in commercial photograhy but has since dedicated herself exclusively to personal projects, exhibiting her work in various group and solo exhibitions in Chile.

Her work has been featured internationally in Colombia, Argentina, USA, Belgium, Peru, Spain, Uruguay, Venezuela, Spain, France, Portugal and Mexico.

She currently teaches photography in the Escuela de Comunicaciones Alpes and works as a freelance veterinarian.

She has authored 3 books to date: “Las Novias de Antonio” (La Revista, 2009), ” Recuérdame al morir con mi último latido” (2010) and “Zaida Gonzalez De Guarda” (2013). Her last two books were published independently with the help of her brother, designer Marco Gonzalez.

She was the recipient of four photography scholarships from Fondart (2005, 2008, 2009 and 2011) and was a resident of fine art photography for Nelson Garrido in Valparaiso (2010).

In 2007 and 2011 she was nominated for the Altazor award for her work “Conservatorio Celestial” and “Recuérdame al morir con mi último latido,” respectively.

In 2012 she won the Rodrigo Rojas De Negri award and national recognition in emerging photography.

In 2013 she was awarded a grant from the DIRAC for a residency she completed with the NGO (Organización Nelson Garrido) in Caracas, Venezuela.

 

Related links

Zaida González Ríos

 

 

0
Your rating: None

William Volk may not be the world's oldest game designer, but he's up there. He started out as a play tester for Avalon Hill in 1979, and since then has worked for Activision and other major players in the game space. His current job is with PlayScreen, where he's working on their Word Carnivale iOS game, which is not violent at all. But over the years Volk has worked on slightly violent video games and has watched public outcries over video game violence since 1976. He's also tracked how much less violence we've seen since lead was removed from gasoline. (Editorial interjection: Aren't most remaining pockets of massive gun violence in cities where many poor kids grow up in apartments that have lead paint?) Due to technical problems during the interview, some of the conversation is missing, primarily about the recent spate of multiple murders. It seems, for instance, that Newtown shooter Adam Lanza was heavily into violent video games, which is sure to spark plenty of new discussion about how they affect players. But then again, as Volk reminded me in an email, "If people were influenced by video games, a majority of Facebook users would be farmers by now," a meme that has been floating around Facebook since last year, if not earlier.

Share on Google+

Read more of this story at Slashdot.

0
Your rating: None

google redesign feature lead

By Dieter Bohn and Ellis Hamburger

Something strange and remarkable started happening at Google immediately after Larry Page took full control as CEO in 2011: it started designing good-looking apps.

Great design is not something anybody has traditionally expected from Google. Infamously, the company used to focus on A/B testing tiny, incremental changes like 41 different shades of blue for links instead of trusting its designers to create and execute on an overall vision. The “design philosophy that lives or dies strictly by the sword of data” led its very first visual designer, Douglas Bowman, to leave in 2009.

More recently, however, it’s been impossible to ignore a series of thoughtfully designed apps — especially on iOS,...

Continue reading…

0
Your rating: None

In an age when “everything is changing, everything is moving,” photographer Nadav Kander has sought to find moments of reserve, reverence and human vulnerability in his latest series, Bodies: 6 Women, 1 Man, opening this week at Flowers Gallery (Cork Street) in London, and published by Hatje Cantz later this month.

Kander told TIME in a recent interview that his work in Bodies — featuring white, smooth figures cast against a stark black background — serves, in part, as a visual homage to fine-art history. But the alabaster forms, naked and undefended, also communicate Kander’s underlying motivation as a photographer: to capture “the paradoxes of the human condition.”

“I don’t like to ignore that there is beauty without imperfection or that there’s health without disease,” Kander says. This interplay between the perfect and the flawed, the pure and the corrupt, suggests an elemental truth — a truth that is central to Kander’s aesthetic and method.

“The nudes,” he told TIME, “are another way of satisfying the quest that I’ve always [pursued] in my work.”

Originally from Israel, the 51-year-old Kander might be best known for his portraits, often uniquely framed and staged in dramatically lit environments. Subjects have ranged from President Barack Obama (for TIME’s 2012 Person of the Year issue) to professional athletes, politicians and Hollywood royalty.

But the range of Kander’s photography extends well beyond the intimate portrait: his documentary photography, for example, has merited awards — most notably Yangtze: The Long River, which won the Prix Pictet prize for photography and sustainability in 2009. With Bodies, however, he has returned to a theme that can sometimes feel archaic, as if abandoned by many in his field.

“In recent years, photographers have stayed away from the nude,” said Kander, noting that the process had become almost “nostalgic.” “I wanted to work with the nude in a new way.”

As if embracing the theme of paradox, Kander’s “new way” required peering into art’s distant past.

“The mixture of dust and cream [applied to the subjects] served as gentle reference to renaissance paintings,” he explained to TIME. Before long, and in spite of his evident reverence for his predecessors in both paint and pictures, his project evolved into a riveting amalgam: fine-art photographs that felt at once deeply familiar and utterly distinct from anything that might have come before.

“While the models are very present and there for your eyes, they are also turned away and quite private,” he said, noting details that contrast with most Renaissance art, which often made use of a Raphaelite “gaze” — that is to say, a portrait’s subject engaging the viewer with direct, and occasionally unsettling, eye contact.

While the bodies in his photos might well relay a vulnerability unseen in more traditional works, the positioning of the figures — the arch of their hands, the flexion of their feet and toes — communicates a Renaissance aesthetic further evident in his casting and choice of models.

“I was into the ideas of effigies, these white marble statues,” he said. To replicate that look Kander chose models without tattoos or piercings, bodies that were — in his words — “unencumbered by modernity.”

In his interview with TIME, Kander noted the influence Edward Weston, a renowned American photographer, has had on his work and approach to photography.

In 1932, Weston and 10 of the industry’s most notable names created the f/64 Group in San Francisco. The loose collective of photographers was staunchly committed to photography at its most accurate. In Weston’s words, “The camera should be used for a recording of life, for rendering the very substance and quintessence of the thing itself, whether it be polished steel or palpitating flesh.”

For Kander, this same sensitivity meant little editing or post-production work on his own images — images that at-once mirror a specific reality and inform his personal life.

“I don’t want to make art that’s simple, ‘correct for the times,’ or merely to fit a gap in the market,” he said. “I make things that nourish me.”

Nadav Kander is a London-based photographer. Kander photographed President Barack Obama for TIME’s Person of the Year Issue in 2012.

0
Your rating: None