Shared posts

28 Aug 17:55

The art of sound in the movies

by Jason Kottke

Skip Lievsay is one of the best sound designers in the business, having won an Oscar for his work on Gravity and worked on such films as Goodfellas, Silence of the Lambs, Do The Right Thing, and all of the Coen brothers' movies. Jordan Kisner recently profiled Lievsay for The Guardian.

It is a central principle of sound editing that people hear what they are conditioned to hear, not what they are actually hearing. The sound of rain in movies? Frying bacon. Car engines revving in a chase scene? It's partly engines, but what gives it that visceral, gut-level grist is lion roars mixed in. To be excellent, a sound editor needs not just a sharp, trained ear, but also a gift for imagining what a sound could do, what someone else might hear.

Tags: audio   Jordan Kisner   movies   Skip Lievsay
22 Jan 18:27

YUIConf 2013 Talk: Markandey Singh on Moonwalking with JavaScript

by Andrew Wooldridge

Welcome to our Wednesday edition of the YUIConf 2013 video series releases. Today we feature a talk from Markandey Singh on Moonwalking with JavaScript. It’s a great talk if you are looking for tips to get your website to load and render faster. As always, you can catch up with the previous video or visit the full playlist on YouTube.

Slides and other information about this talk available on GitHub.

11 Nov 18:30

Sourced Quotes, 17

Don't worry about people stealing an idea. If it's original, you will have to ram it down their throats. -- Howard Aiken, as quoted in Portraits in Silicon by Robert Slater, 1987, p. 88.

Machines will do what we ask them to do and not what what we ought to ask them to do. -- Norbert Wiener, 1949, published in John Markoff, NYTimes May 21, 2013

The shortcut that's sure to work, every time: Take the long way. Do the hard work, consistently and with generosity and transparency. And then you won't waste time doing it over. -- Seth Godin, Seth's Blog, May 13, 2013.

Most people doubt online meetings can work but they somehow overlook that most in-person meetings don't work either. - Scott Berkun, The Year Without Pants, p. 42, September 2013.

It's total chaos. But out of that chaos will come some really amazing things. And right now there are amazing opportunities for young people coming into the industry to say, ‘Hey, I think I'm going to do this and there's nobody to stop me.' It's because all the gatekeepers have been killed! -- George Lucas, The Verge, June 13, 2013.

If the NSA released their heaps of prying spycode as open-source code, Silicon Valley would be all over that, instantly. They’d put a kid-friendly graphic front-end on it. They’d port it right into the cloud. -- Bruce Sterling, The Ecuadorian Library, August 3, 2013.

I believe that the purpose of death is the release of love. -- Laurie Anderson, Farewell to Lou Reed, Rolling Stone, November 21, 2013

The question [in Hollywood] used to be: How do we top ourselves? The new one seems to be: How do we stop ourselves? -- Damon Lindelof, The New Rules of Blockbuster Screenwriting, Vulture, August 14, 2013

If you take someone to lunch you just get each other's stories, but if you set up folding chairs together, you find out what people are really like. -- Anne Herbert, The Whole Earth Jamboree Wasn't Worth It Once, CoEvolution Quarterly, Winter 1978.

People are bad at looking at seeds and guessing what size tree will grow out of them. The way you'll get big ideas in, say, health care is by starting out with small ideas. If you try to do some big thing, you don't just need it to be big; you need it to be good. And it's really hard to do big and good simultaneously. So, what that means is you can either do something small and good and then gradually make it bigger, or do something big and bad and gradually make it better. And you know what? Empirically, starting big just does not work. That's the way the government does things. They do something really big that's really bad, and they think, Well, we'll make it better, and then it never gets better. -- Paul Graham, Building Fast Companies for Growth, Inc. September 2013

Simple answers
Simple answers from xkcd

06 Jan 14:07

Release of Apache Cayenne, version 3.2M1

Apache Cayenne Cayenne is a powerful, full-featured, opensource framework created for developers working with relational databases. it seamlessly maps any relational database to Java objects, reducing development time and adding considerable functionality to any application which requires a database. Developers using Cayenne will be able to concentrate on the core business requirements and the data model instead of the SQL details. The application can then be easily moved to any JDBC-capable database. In addition to management of persistent Java objects mapped to relational databases, Cayenne provides a plethora of features including single method call queries and updates (including atomic updates of all modified objects), seamless integration of multiple databases into a single virtual data source, three tier persistence with caching on the remote client, paging of results, record locking, and many more features.
15 Aug 05:15

10 Ways To Use Message Queues

by mitchp
This article is high level without any specific examples (but there are links) of these usages, but it's a good reference for beginners or even intermediate message queue users who may not have thought about all of these possibilities. Preview Text:  This article is high level without any specific examples (but there are links) of these usages, but...
08 Jul 14:50

Salesforce Onboarding Done Right!

by Mike Gerholdt

I get all kinds of questions from readers and I love them, some of them are very challenging and some make for great blog posts. So recently I got a question from a reader looking for advice about onboarding a fairly large department to Salesforce. And while I’ve been through many deployments of Salesforce each one presents a new and different challenge. But as with each challenge- planning and communication is key. For the sake of brevity I’m going to assume that you have already met with the department, gathered requirements, built the app, and finished with user acceptance testing- meaning it’s time to train and onboard them. The goal with any deployment is a high adoption rate so let’s build our plan with that goal in mind. Build your Communication Plan The key to any deployment and onboarding project is communication. To get our roll-out on the success track

The post Salesforce Onboarding Done Right! appeared first on ButtonClick Admin.

03 Jun 14:50

Salesforce Workflow Rules- My Wishlist

by Mike Gerholdt

I can’t recall the last time I did a post like the one you are about to read, in fact I may never have written a post like this before. But after hosting a couple fantastic posts about Visual Workflow I think it’s time we address the 800lb. gorilla in the room- namely Salesforce Workflow Rules and Approval processes. No doubt they were forward thinking when they were released in Salesforce, I mean functionality like this usually only comes with code. But since their release they have been left out to pasture. With the direction of Salesforce clearly pointed in a mobile direction I’m losing hope that these fabulous ButtonClick Admin friendly features will be left in the pasture- relics of an era that has been forgotten. So in one last attempt to raise awareness I’m putting together my list of improvements that I believe will help ButtonClick Admins take

The post Salesforce Workflow Rules- My Wishlist appeared first on ButtonClick Admin.

09 Jun 20:03

Are you important? (Emotions vs. Actions)

by Scott

When people say “you know you are important to me” the best answer is “I don’t know.” Think about it before you answer. There’s great social pressure to say “yes, of course I know that” when asked by a parent, spouse, boss or old friend,  but that pressure confuses your abstract feelings about a person with an evaluation of how they behave towards you. Feelings and actions are different things, and the fact someone feels you are important to them doesn’t guarantee they treat you well, or that they should be important to you.

Feelings and actions are different things. As important as feelings are, if they don’t influence behavior feelings have little meaning for anyone but the person having them. If I love you, but treat you horribly, or ignore you, or behave selfishly and never consider your needs in any of my actions, I’m betraying those feelings (whether I realize it or not). It’s therefore not about whether I love you or care about you, but how my behavior towards you reflects those feelings. That’s the basis for healthy relationships: a connection between feelings and behavior, or emotions and actions. All too often our actions and emotions are disconnected from each other. Either through fear, disfunction, or ignorance, our emotions never make it out of our hearts and into actions that have meaning for the people we care about most. Integrity is the proximity of your beliefs to your actions, and we need more integrity in this world.

There are similar truths in the workplace.  To be told a project is important, but not to get the resources you need to do it well is a kind of lie. It’s a disconnect between the word “important” and any action that would embody importance. The person with the disconnect might not realize they are betraying themselves, but they are. Either you’re not important enough to deserve the resources and they’re deceiving you by using that word, or they are incompetent in not giving you the resources your importance merits.

It’s a low bar to ask “you know you’re important to me, right?” The better question is “does my behavior express to you how important you are?”

04 Jun 16:39

Book Review: Microinteractions

by Scott

microinteractions_comp1-228x300They say the devil is in the details, but the angels are in there too. That is, if you have a clue about what you’re doing. People who want to design things have large egos and presume that they’re skilled enough to work on large, grand ideas. But so rarely do designs in this world get the small things right, and if the small things, the little pieces that get used the most, are broken, what is the point of being large?

Dan Saffer’s book Microinteractions is the best book I’ve read about design in ages. I’ve been working in design for 20 years and often have younger designers ask me for advice, or how to achieve their grand design dreams. Most books about design are similarly grand and presume that everyone knows the basics well enough to do the little things well. The world proves this not to be true. Spend an afternoon strolling around town with a gaggle of caffeinated interaction designers and you’ll hear an endless commentary on the details the designers of the world have gotten wrong.

The book itself is a wonderfully self-consistent: it’s short, concise, well designed and brilliant. The fun and salient examples nail Saffer’s points, and his writing is sharp, incisive and with just enough comedic curmudgeonry to keep you smiling most of the way through. The book’s ambitions, like any good design project, are clear. Saffer’s focus is on the small sequences of interactions he calls, surprise, microinteractions. Ever been frustrated by entering your password? Leaving a comment on a blog? You’ve been let down by a microinteraction design. Perhaps the majority of design frustrations in the technological world are micro, not macro.

This is the book many designers will begrudgingly pick up, thinking it’s beneath them, but by the time they get to page 25 they’ll be thinking “oh, this is fun” and then by page 50 they’ll realize “oh dear, I make that mistake, or have peers that do” and when they’re finished they’ll know “I now have a language to describe these important problems that have bothered people for ages but were hard to describe, and I have the knowledge now to fix them properly”. What more can you ask for from a book about designing things?

We live in a world where the clueless have disturbing amounts of influence. There are no licenses required to use words like design, simplicity and quality, and it should be no surprise we’re often victimized by the engineered junk companies pass off as products. If we want that to change we have to start in the small. Until a designer, or an organization, can consistently get the details right, what hope is there to get the grand things right either?

Please buy this book. I say that selfishly as I want better design in the world. But I also say it generously: so many design books are fluffy affairs, lost in abstraction and ego. Saffer has hit the bullseye of problems the design world desperately needs to solve, and written a book every designer needs to read.

A free chapter is here (PDF) and the book has its own website.


10 Jun 15:27

The 10 Deadly Sins Against Scalability

by Todd Hoff

In the moral realm there may be 7 deadly sins, but scalability maven Sean Hull has come up Five More Things Deadly to Scalability that when added to his earlier 5 Things That are Toxic to Scalability, make for a numerologically satisfying 10 sins again scalability:

  1. Slow Disk I/O – RAID 5 – Multi-tenant EBS. Use RAID 10, it provides  good protection along with good read and write performance. The design of RAID 5 means poor performance and long repair times on failure. On AWS consider Provisioned IOPS as a way around IO bottlenecks.
  2. Using the database for Queuing. The database may seem like the perfect place to keep work queues, but under load locking and scanning overhead kills performance. Use specialized products like RabbitMQ and SQS to remove this bottleneck.
  3. Using Database for full-text searching. Search seems like another perfect database feature. At scale search doesn't perform well. Use specialized technologies like Solr or Sphinx.
  4. Insufficient Caching at all layers. Use memcache between your application and the database. Use a page like cache like Varnish between users and your webserver. Select proper caching options for your html assets.
  5. Too much technical debt. Rewrite problem code instead of continually paying a implementation tax for poorly written code. In the long run it pays off.
  6. Object Relational Mappers. Create complex queries that hard to optimize and tweak.
  7. Synchronous, Serial, Coupled or Locking Processes. Locks are like stop signs, traffic circles keep the traffic flowing. Row level locking is better than table level locking. Use async replication. Use eventual consistency for clusters.
  8. One Copy of Your Database. A single database server is a choke point. Create parallel databases and let a driver select between them.
  9. Having No Metrics. Visualize what's happening to your system using one of the many monitoring packages.
  10. Lack of Feature Flags. Be able to turn off features via a flag so when a spike hits features can be turned off to reduce load.
10 Jun 13:20

Request Quest

by Chris Coyier

Jake Archibald put together an interesting and informative quiz about when browsers actually make requests. I learned a bunch. Some of it might seem like quirky academic knowledge but we all know how often unpredictably weird situations come up in day to day dev work.

Jake wished me to point out that it is unfinished (only works on desktop Chrome) and might hurt your feelings if you can't take browser insult jokes.

Direct Link to ArticlePermalink

Request Quest is a post from CSS-Tricks

14 Jun 14:58

Optimal Logging

by Google Testing Bloggers
by Anthony Vallone

How long does it take to find the root cause of a failure in your system? Five minutes? Five days? If you answered close to five minutes, it’s very likely that your production system and tests have great logging. All too often, seemingly unessential features like logging, exception handling, and (dare I say it) testing are an implementation afterthought. Like exception handling and testing, you really need to have a strategy for logging in both your systems and your tests. Never underestimate the power of logging. With optimal logging, you can even eliminate the necessity for debuggers. Below are some guidelines that have been useful to me over the years.

Channeling Goldilocks

Never log too much. Massive, disk-quota burning logs are a clear indicator that little thought was put in to logging. If you log too much, you’ll need to devise complex approaches to minimize disk access, maintain log history, archive large quantities of data, and query these large sets of data. More importantly, you’ll make it very difficult to find valuable information in all the chatter.

The only thing worse than logging too much is logging too little. There are normally two main goals of logging: help with bug investigation and event confirmation. If your log can’t explain the cause of a bug or whether a certain transaction took place, you are logging too little.

Good things to log:
  • Important startup configuration
  • Errors
  • Warnings
  • Changes to persistent data
  • Requests and responses between major system components
  • Significant state changes
  • User interactions
  • Calls with a known risk of failure
  • Waits on conditions that could take measurable time to satisfy
  • Periodic progress during long-running tasks
  • Significant branch points of logic and conditions that led to the branch
  • Summaries of processing steps or events from high level functions - Avoid logging every step of a complex process in low-level functions.

Bad things to log:
  • Function entry - Don’t log a function entry unless it is significant or logged at the debug level.
  • Data within a loop - Avoid logging from many iterations of a loop. It is OK to log from iterations of small loops or to log periodically from large loops.
  • Content of large messages or files - Truncate or summarize the data in some way that will be useful to debugging.
  • Benign errors - Errors that are not really errors can confuse the log reader. This sometimes happens when exception handling is part of successful execution flow.
  • Repetitive errors - Do not repetitively log the same or similar error. This can quickly fill a log and hide the actual cause. Frequency of error types is best handled by monitoring. Logs only need to capture detail for some of those errors.

There is More Than One Level

Don't log everything at the same log level. Most logging libraries offer several log levels, and you can enable certain levels at system startup. This provides a convenient control for log verbosity.

The classic levels are:
  • Debug - verbose and only useful while developing and/or debugging.
  • Info - the most popular level.
  • Warning - strange or unexpected states that are acceptable.
  • Error - something went wrong, but the process can recover.
  • Critical - the process cannot recover, and it will shutdown or restart.

Practically speaking, only two log configurations are needed:
  • Production - Every level is enabled except debug. If something goes wrong in production, the logs should reveal the cause.
  • Development & Debug - While developing new code or trying to reproduce a production issue, enable all levels.

Test Logs Are Important Too

Log quality is equally important in test and production code. When a test fails, the log should clearly show whether the failure was a problem with the test or production system. If it doesn't, then test logging is broken.

Test logs should always contain:
  • Test execution environment
  • Initial state
  • Setup steps
  • Test case steps
  • Interactions with the system
  • Expected results
  • Actual results
  • Teardown steps

Conditional Verbosity With Temporary Log Queues

When errors occur, the log should contain a lot of detail. Unfortunately, detail that led to an error is often unavailable once the error is encountered. Also, if you’ve followed advice about not logging too much, your log records prior to the error record may not provide adequate detail. A good way to solve this problem is to create temporary, in-memory log queues. Throughout processing of a transaction, append verbose details about each step to the queue. If the transaction completes successfully, discard the queue and log a summary. If an error is encountered, log the content of the entire queue and the error. This technique is especially useful for test logging of system interactions.

Failures and Flakiness Are Opportunities

When production problems occur, you’ll obviously be focused on finding and correcting the problem, but you should also think about the logs. If you have a hard time determining the cause of an error, it's a great opportunity to improve your logging. Before fixing the problem, fix your logging so that the logs clearly show the cause. If this problem ever happens again, it’ll be much easier to identify.

If you cannot reproduce the problem, or you have a flaky test, enhance the logs so that the problem can be tracked down when it happens again.

Using failures to improve logging should be used throughout the development process. While writing new code, try to refrain from using debuggers and only use the logs. Do the logs describe what is going on? If not, the logging is insufficient.

Might As Well Log Performance Data

Logged timing data can help debug performance issues. For example, it can be very difficult to determine the cause of a timeout in a large system, unless you can trace the time spent on every significant processing step. This can be easily accomplished by logging the start and finish times of calls that can take measurable time:
  • Significant system calls
  • Network requests
  • CPU intensive operations
  • Connected device interactions
  • Transactions

Following the Trail Through Many Threads and Processes

You should create unique identifiers for transactions that involve processing across many threads and/or processes. The initiator of the transaction should create the ID, and it should be passed to every component that performs work for the transaction. This ID should be logged by each component when logging information about the transaction. This makes it much easier to trace a specific transaction when many transactions are being processed concurrently.

Monitoring and Logging Complement Each Other

A production service should have both logging and monitoring. Monitoring provides a real-time statistical summary of the system state. It can alert you if a percentage of certain request types are failing, it is experiencing unusual traffic patterns, performance is degrading, or other anomalies occur. In some cases, this information alone will clue you to the cause of a problem. However, in most cases, a monitoring alert is simply a trigger for you to start an investigation. Monitoring shows the symptoms of problems. Logs provide details and state on individual transactions, so you can fully understand the cause of problems.

25 May 17:44

HTML5 vs. Native App Battle

by Erik C. Thauvin