by via Awwwards - Sites of the day
Wednesday, August 31, 2016
Susa Ventures
by via Awwwards - Sites of the day
10 Top On-Page Tips To Improve Social Media Marketing Results
The best social media marketing campaigns are those that combine both off-page and on-page elements. Creating great content on Twitter, Snapchat, and YouTube can help create a buzz, but unless this ties in with effective on-site content that has been optimized to convert, it won’t generate the kind of conversions that your great quality social content deserves.
by Guest Author via Digital Information World
The Harmony of Teams: A considered approach to making meaningful work collaboratively
At the end of 2012 Jo and I were professionally stuck. We were faced with a stark question about Apogee’s consulting work and the direction of the business going forward; What if UX was not really our intention in the work that we do?
It was a hard question to answer. We had invested so much time and energy into the way we do things, and we were finding it hard to slow down and seek alternative directions.
So we took a trip to Chengdu, mainland China, with our friends and advisors Bas and Geke from STBY. It was a deliberate space to enjoy relaxed conversations about our work, vent our shared frustrations, connect related topics and perspectives from thinking outside the field of design, and to touch on our toolkits and where we thought our practice was going.
Project inspection and flow
The natural flow of our conversations allowed us to share stories, reflect on and make sense of what our new thinking meant for our respective practices, and to better understand how each of us wanted to help our clients, now and in the future, with meaningful work.
We began to move away from our habitual ways of looking at our work and let go of the language that we had been using.
We gave ourselves permission to pursue the freedom of thought that would enable us to see things anew.
We started talking about how teams work together. In our experience, the good energies a team brings to a new project can quickly get derailed if people don’t feel they have a clear understanding of why they’re working on something.
Opinion wars escalate when there is no customer involvement that could let us better understand their needs—both now and over time.
What’s the best way teams can create meaningful work together?
Teams create additional features to support their own egos and opinions, without grounding their justification in evidence of what customers actually need. Sometimes, during a project, people create conflicts that serve only to get in the way of making meaningful work together.
Unnecessary and petty battles suck the fun out of work and prevent it from being productive.
Why do people create this conflict?
You’ve probably experienced at least one of these scenarios in a project you’ve been part of:
- The team did not collect, or clearly understand, the requirements
- The team did not properly define the core of the offering
- There was too much distance between the customer and the project goals
- The organisation had already invested too much in the project to allow it to fail
- The team simply did not know how to get along.
These factors all contribute to creating an environment of fear and uncertainty that prevents people from working together to create wonderful products and services.
So, what are the elements of a project we need to be thinking about to help bring people together to make meaningful things as a team?
1. Define the core of what you make
It’s important for everyone on a team—independent of their discipline—to have a clear idea of the core features and value proposition of the product or service they’re creating.
What is the primary reason a customer would want to buy, rent, or subscribe to a product or service? How would customers go about completing their goals? How could a product or service better serve customers and the business over time?
2. Inform design through customer stories, and engage in sense-making with your team
Create a regular routine for learning about and understanding your customers so your team can make sense of customer insights together.
Transforming customer stories into valuable, accurate information, and using sense-making techniques, enables a team to engage in well-informed product or service design rather than relying on random, inaccurate assumptions.
Staying close to your customers, rather than making assumptions, keeps your project on track.
You could do this through asking questions, looking at data through the lenses of various disciplines, and having multidisciplinary conversations. Collecting this data helps you to map product and service features and solutions to customers’ actual needs and desires.
3. Share observations in a shared context
Don’t underestimate the importance of sharing, as a group, your individual and collective observations about customer and stakeholder behaviours. This enables teams to identify surprising or deeply memorable situations that deserve further analysis.
Sharing stories with other team members and groups makes way for a broader interpretation of the stories, which can help to make sense of everyone’s observations and determine what artefacts would give their observations and insights life.
Once your team develops a routine for sharing these stories, you can start to list assumptions, discuss the sources and the evidence available to support them. You can then either challenge or accept particular assumptions, or sets of assumptions, depending on the insights gained from sharing customer observations. As a team, this helps to prioritise particular features by determining those that deserve more of the team’s time, focus, and attention, and identifying which features require more research or further design iterations.
Using customer data to inform design decisions through sense-making is not a one-off activity. Nor is it just the responsibility of the user researcher or UX lead. It should be a constant activity that is integral to conducting business. Without this kind of research and sense-making, a business simply won’t be able to innovate over time.
4. Give people time to think
Delivering projects against a static set of requirements without taking a break to reflect on the project and get a clear outlook is a sure way to lose perspective and stifle innovation.
People need time and space so they can look beyond the current work in progress and reflect on how a product or service could look in the future. Allow people to get away from their desk and computer. Encourage conversations outside the project. Give people time to think so they have an opportunity to tackle problems with a fresh mind.
Let’s answer a question together
How can we (UXers) make routines to contribute to the intention of wellness for people, work, projects, communities and economies for an enlightened future society?
We need your help to answer: how can we make meaningful work?
What if you…
- Possess all the social permission you need to change personal habits?
- Spent an hour of everyday examining the potential for significance of a project?
- Began listening to and imploring others for their motives rather than their threats?
- Replace “what do I stand to lose?” with “what might we all need to gain?”
- Openly discussed the projects you work on mattered and where the best work felt like play and the best play felt like work?
- Welcomed all disciplines to create a broader ‘community of aspiration’ and signed an implicit contract to make meaningful work for every project we put our hands to?
It is the ability of teams to come together and intentionally create something great that enables organisations to achieve stellar results. With the help of integrated approaches. and the practices that guide them, we’ll not only become better at working well together but also, hopefully, get more enjoyment from our work.
What makes work meaningful work for you? Share your thoughts in the forums.
The post The Harmony of Teams: A considered approach to making meaningful work collaboratively appeared first on UX Mastery.
by Dan Szuc and Josephine Wong via UX Mastery
9 Google Analytics Tips to Improve Your Marketing
Do you use Google Analytics? Are you leveraging the many apps that work with Google Analytics? Integrating data from third-party tools, plugins and platforms with Google Analytics helps you gain insight about your online marketing efforts. In this article I’ll share nine tips to help you get more out of Google Analytics. Listen to this article: You can [...]
This post 9 Google Analytics Tips to Improve Your Marketing first appeared on .
- Your Guide to the Social Media Jungle
by Kristi Hines via
The Beginners Guide to WordPress SEO
WordPress is used by millions of people right around the world to setup websites for a variety of applications. While it’s popular because it’s easy to get up and running and use, it still requires proper optimization in order to really improve your overall search engine rankings.
This guide will give WordPress beginners a basic overview of WordPress SEO to help your website get found online.
This article will cover:
- Title Tags
- Meta Descriptions
- Permalinks
- Keyword Phrases
- Alt Text
- Internal Linking
- The Yoast SEO Plugin
- Basic Keyword Research
- WordPress Tweaks
So let’s get started!
Your Guide to WordPress Search Engine Optimization
Title Tags
Title tags are used in the head section of a web page to communicate your page title better to both search engines and visitors. WordPress generally features a number of different pages which include just to name a few:
- Home page
- Individual pages
- Archived post views
- Single post views
- Category archives
- Date-based archives
- Author archives
- 404 error pages
- Tag archives
- Search results
- Category archives
- Archived post views
Title tags help to boost SEO efforts which in-turn can help to boost your overall rankings. The title tag will tell your visitors what the post is about before they click into it. The title tag is generally seen in search engine results as shown below:
Meta Descriptions
In WordPress, if you’ve installed the Yoast SEO plugin (which we'll cover later), you’ll see an area for the meta description and keyword to be implemented. For optimal SEO, the meta description should include the relevant keyword that’s going to be used for the overall post. The title of your post should also feature the relevant keyword for optimal impact. It's important to make your content clear for users, not just search engines.
Continue reading %The Beginners Guide to WordPress SEO%
by Aaron Gray via SitePoint
How to Translate from DOM to SVG Coordinates and Back Again
All the cool kids are using Scalable Vector Graphics. SVGs are great until you want to mix DOM and vector interactions -- then life becomes more complicated.
SVGs have their own coordinate system. It is defined via the viewbox attribute, e.g. viewbox="0 0 800 600" which sets a width of 800 units and a height of 600 units starting at (0, 0). If you position this SVG in an 800x600 pixel area, each SVG unit maps directly to a screen pixel.
However, the beauty of vector images is they can be scaled to any size. Your SVG could be scaled in a 400x300 space or even stretched beyond recognition in a 100x1200 space. Adding further elements to an SVG becomes difficult if you don't know where to put them.
(SVG coordinate systems can be confusing - Sara Soueidan's viewport, viewBox and preserveAspectRatio article describes the options.)
Simple Separated SVG Synergy
You may be able to avoid translating between coordinate systems entirely.
SVGs embedded in the page (rather than an image or CSS background) become part of the DOM and can be manipulated in a similar way to other elements. For example, given a basic SVG with a single circle:
[code language="html"]
<svg id="mysvg" xmlns="http://ift.tt/nvqhV5" viewBox="0 0 800 600" preserveAspectRatio="xMidYMid meet">
<circle id="mycircle" cx="400" cy="300" r="50" />
<svg>
[/code]
we can apply CSS effects:
[code language="css"]
circle {
stroke-width: 5;
stroke: #f00;
fill: #ff0;
}
circle:hover {
stroke: #090;
fill: #fff;
}
[/code]
and attach event handlers to modify their attributes:
[code language="javascript"]
var mycircle = document.getElementById('mycircle');
mycircle.addEventListener('click', function(e) {
console.log('circle clicked - enlarging');
mycircle.setAttributeNS(null, 'r', 60);
}, false);
[/code]
The following example adds thirty random circles to an SVG image, applies a hover effect in CSS and uses JavaScript to increase the radius by ten units when a circle is clicked:
See the Pen SVG interaction by SitePoint (@SitePoint) on CodePen.
SVG to DOM Coordinate Translation
What if we want to overlay a DOM element on top of an SVG item, e.g. a menu or information box on a map? Again, because our HTML-embedded SVG elements form part of the DOM we can use the fabulous getBoundingClientRect() method to return all dimensions in a single call. Open the console in the example above to reveal the clicked circle's new attributes following a radius increase.
Element.getBoundingClientRect() is supported in all browsers and returns an DOMrect object with the following properties in pixel dimensions:
.xand.left- x-coordinate, relative to the viewport origin, of the left side of the element.right- x-coordinate, relative to the viewport origin, of the right side of the element.yand.top- y-coordinate, relative to the viewport origin, of the top side of the element.bottom- y-coordinate, relative to the viewport origin, of the bottom side of the element.width- width of the element (not supported in IE8 and below but is identical to.rightminus.left).height- height of the element (not supported in IE8 and below but is identical to.bottomminus.top)
Continue reading %How to Translate from DOM to SVG Coordinates and Back Again%
by Craig Buckler via SitePoint
Using ViewPager to Create a Sliding Screen UI in Android
Android provides many UI controls to create beautiful UI screens for your apps. One common UI requirement is sliding between multiple screens. For example, a photo slideshow. Android provides a UI control for creating sliding screens called the ViewPager. This tutorial will explain using ViewPager to create a sliding screen UI in your Android apps.
Continue reading %Using ViewPager to Create a Sliding Screen UI in Android%
by Abbas Suterwala via SitePoint
Product Builder with CSS and jQuery
Product Builder is a customizable and responsive product builder for your online store by using CSS and jQuery.
by via jQuery-Plugins.net RSS Feed
This Week's HTML5 and Browser Technology News (Issue 255)
|
by via FrontEnd Focus
Brooks Creative WP Theme
Brooks WP – Creative Multi-Purpose WordPress Theme Brooks is a Perfect Multi-Purpose WordPress Theme for Digital Agencies, Creative Studios, Real Estate websites, Blogging, Portfolio, Shop, etc. Brooks is a fresh look at design, thousands hours of
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Antigo
Hello my name is Antigo.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
gloops special drama ONETEAM
We’ve launched 6-part of dramas and a special website for a Game development company called
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
BankBound
Digital marketing agency for the banking industry.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Jordy Alblas, Webdesigner/Developer
Freelance Web Designer & Developer from The Netherlands. Creative websites for you, your company or project. Bring your story to life.
by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery
Let's Go: Command-Line Programs With Golang
Overview
The Go Language is an exciting new language that gains a lot of popularity for a good reason. In this tutorial you'll learn how to write command-line programs with Go. The sample program is called multi-git, and it allows you to execute git commands on multiple repositories at the same time.
Quick Introduction to Go
Go is an open-source C-like language created at Google by some of the original C and Unix hackers, who were motivated by their dislike of C++. It shows in Go's design, which made several unorthodox choices such as eschewing implementation inheritance, templates, and exceptions. Go is simple, reliable, and efficient. Its most distinctive feature is its explicit support for concurrent programming via so-called goroutines and channels.
Before starting to dissect the sample program, follow the official guide to get ready for Go development.
The Multi-Git Program
The multi-git program is a simple but useful Go program. If you work on a team where the codebase is split across multiple git repositories then you often need to perform changes across multiple repositories. This is a problem because git has no concept of multiple repositories. Everything revolves around a single repository.
This becomes especially troublesome if you use branches. If you work on a feature that touches three repositories then you will have to create a feature branch in each of these repositories and then remember to check out, pull, push, and merge all of them at the same time. This is not trivial. Multi-git manages a set of repositories and lets you operate on the whole set at once. Note that the current version of multi-git requires that you create the branches individually, but I may add this feature at a later date.
By exploring the way multi-git is implemented, you will learn a lot about writing command-line programs in Go.
Packages and Imports
Go programs are organized in packages. The multi-git program consists of a single file called main.go. At the top of the file, the package name 'main' is specified, followed by a list of imports. The imports are other packages that are used by multi-git.
package main
import (
"flag"
"fmt"
"log"
"os"
"strings"
"os/exec"
)
For example, the fmt package is used for formatted I/O similar to C's printf and scanf. Go supports installing packages from a variety of sources via the go get command. When you install packages, they end up in a namespace under the $GOPATH environment variable. You can install packages from a variety of sources such as GitHub, Bitbucket, Google code, Launchpad, and even IBM DevOps services via several common version control formats such as git, subversion, mercurial and bazaar.
Command-Line Arguments
Command-line arguments are one of the most common forms of providing input to programs. They are easy to use, allow you to run and configure the program in one line, and have great parsing support in many languages. Go calls them command-line "flags" and has the flag package for specifying and parsing command-line arguments (or flags).
Typically, you parse command-line arguments at the beginning of your program, and multi-git follows this convention. The entry point is the main() function. The first two lines define two flags called "command" and "ignoreErrors". Each flag has a name, a data type, a default value, and a help string. The flag.Parse() call will parse the actual command-line passed to the program and will populate the defined flags.
func main() {
command := flag.String("command", "", "The git command")
ignoreErrors := flag.Bool(
"ignore-errors",
false,
"Keep running after error if true")
flag.Parse()
It is also possible to access undefined arguments via the flag.Args() function. So, flags stand for pre-defined arguments and "args" are unprocessed arguments. The unprocessed arguments are 0-based indexed.
Environment Variables
Another common form of program configuration is environment variables. When you use environment variables, you may run the same program multiple times in the same environment, and all runs will use the same environment variables.
Multi-git uses two environment variables: "MG_ROOT" and "MG_REPOS". Multi-git is designed to manage a group of git repositories that have a common parent directory. That's "MG_ROOT". The repository names are specified in "MG_REPOS" as a comma-separated string. To read the value of an environment variable you can use the os.Getenv() function.
// Get managed repos from environment variables
root := os.Getenv("MG_ROOT")
if root[len(root) - 1] != '/' {
root += "/"
}
repo_names := strings.Split(os.Getenv("MG_REPOS"), ",")
Verifying the Repository List
Now that it found the root directory and the names of all the repositories, multi-git verifies that each repository exists under root and that it is really a git repository. The check is as simple as looking for a .git sub-directory for each repository directory.
First, an array of strings named "repos" is defined. Then it iterates over all the repo names and constructs a repository path by concatenating the root directory and the repo name. If the [os.Stat()]() call fails for the .git subdirectory, it logs the error and exits. Otherwise, the repository path is appended to the repos array.
var repos []string
// Verify all repos exist and are actually git repos (have .git sub-dir)
for _, r := range repo_names {
path := root + r
_, err := os.Stat(path + "/.git")
if err != nil {
log.Fatal(err)
}
repos = append(repos, path)
}
Go has a unique error-handling facility where functions often return both a return value and an error object. Check out how os.Stat() returns two values. In this case the "_" placeholder is used to hold the actual result because you only care about the error. Go is very strict and requires named variables to be used. If you don't plan to use a value, you should assign it to "_" to avoid compilation error.
Executing Shell Commands
At this point, you have your list of repository paths where we want to execute the git command. As you recall, we received the git command line as a single command-line argument (flag) called "command". This needs to be split into an array of components (git command, sub-command, and options). The whole command as a string is stored too for display purposes.
// Break the git command into components (needed to execute)
var git_components []string
for _, component := range strings.Split(*command, " ") {
git_components = append(git_components, component)
}
command_string := "git " + *command
Now, you're all set to iterate over each repository and execute the git command in each one. The "for ... range" loop construct is used again. First, multi-git changes its working directory to the current target repo "r" and prints the git command. Then it executes the command using the exec.Command() function and prints the combined output (both standard output and standard error).
Finally, it checks if there was an error during execution. If there was an error and the ignoreErrors flag is false then multi-git bails out. The reason for optionally ignoring errors is that sometimes it's OK if commands fail on some repos. For example, if you want to check out a branch called "cool feature" on all the repositories that have this branch, you don't care if the checkout fails on repositories that don't have this branch.
for _, r := range repos {
// Go to the repo's directory
os.Chdir(r);
// Print the command
fmt.Printf("[%s] %s\n", r, command_string)
// Execute the command
out, err := exec.Command("git", git_components...).CombinedOutput()
// Print the result
fmt.Println(string(out))
// Bail out if there was an error and NOT ignoring errors
if err != nil && !*ignoreErrors {
os.Exit(1)
}
}
fmt.Println("Done.")
Conclusion
Go is a simple yet powerful language. It's designed for large-scale system programming but works just fine for small command-line programs too. Go's minimal design is in stark contrast to other modern languages like Scale and Rust that are very powerful and well-designed too, but have a very steep learning curve. I encourage you to try Go and experiment. It's a lot of fun.
by Gigi Sayfan via Envato Tuts+ Code
This Week in Mobile Web Development (#123)
|
Brian Rinaldi recommends
Chris Brandrick recommends
Holly Schinsky recommends
by via Mobile Web Weekly
The OpenTypes
Minimal One Pager for 'The OpenTypes', a book for typography lovers by Richards Partners.
by Rob Hope via One Page Love
5 Ways to Enhance YouTube Videos for Marketers
Do you use YouTube for your business? Looking for ways to create more visibility for your videos? YouTube offers a number of helpful features to optimize your videos for more views, subscribers, or conversions. In this article, you’ll discover five ways to improve the performance of your YouTube videos. #1: Add a Watermark to Your [...]
This post 5 Ways to Enhance YouTube Videos for Marketers first appeared on .
- Your Guide to the Social Media Jungle
by Mohammad Farooq via
“I use my strengths and weaknesses to add value to my team : Ask Me Anything.”
In today’s diverse landscape of work places and situations, finding a team that is a good cultural fit is as important as finding a job.
Being able to define achievable team goals that work for every member is key to moving forward in a cohesive, productive, and fulfilling way – it’s how we make meaningful work.
Understanding your personal strengths and weaknesses and learning how to harness those in a way that adds value to your team can go a long way towards making you all happier and more efficient.
Natalie Eustace embarked on a personal journey of discovery to overcome challenges and bring her best to the dispersed team with which she works.
The Details
- Where: Our dedicated ‘Ask Natalie’ Slack channel (You’ll need to request an invitation if you haven’t yet joined our Slack channel)
- When: 4pm Wednesday 7 September PDT or 9am Thursday 8 September AEST
(or find out what time that is for you)
Meet Natalie Eustace
Natalie is a UX Designer with Wynyard Group – a market leader in serious crime fighting software used by governments and financial institutions.
Starting in the role as a graduate and working her way up, Natalie works in a geographically widespread team who have to work hard to find ways to work cohesively together, with ideation and communication proving to be ongoing challenges.
How to Ask Your Questions
If you can’t make the live session but have questions, we’d love to collect them ahead of time and we’ll ask Natalie on your behalf. You can submit your questions here. We’ll publish the responses (along with the full transcript) in the days following the session.
How does Ask Me Anything work?
These sessions run for approximately an hour and best of all, they don’t cost a cent. We run them in our dedicated public Slack channel. That means that there is no audio or video, but a full transcript will be posted up on here in the days following the session. If you’re not familiar with Slack, you’ll need to request an invite to our channel the first time only – from then on you’re part of the family and you’ll have automatic access to new sessions.
The post “I use my strengths and weaknesses to add value to my team : Ask Me Anything.” appeared first on UX Mastery.
by Sarah Hawk via UX Mastery
Femme Fatale Studio
by via Awwwards - Sites of the day
Tuesday, August 30, 2016
How to create Shareable Content Using Infographics
We are becoming more used to be served business statistics on an eye-catching infographic design rather than listed monotonously in a word document. We don’t mind the colours and imagery which comes along with infographics because it is in our nature to be captured by visuals!
Infographics come in all shapes and sizes, however, if you have missed them they tend to be super long graphics that are easy to scroll through and understand no matter what your background in the relevant subject is.
Infographics can be extremely valuable to your company and they may even boost the reach of your business through social media sharing and blogs! If you are a small business looking to adapt to big business trends infographics are an excellent start.
Let’s look at how you can create shareable content through infographics, that will grab your target audience’s attention.
by Guest Author via Digital Information World
Web Design Weekly #250
Articles
Writing Less Damn Code
I’m a bit of a fan of Heydon Pickering’s thinking to be honest but it is a fine line. In this post Heydon shares a few use cases of why we should all aim to write less code and passes on few tips and ideas that might help us achieve the desired result. (heydonworks.com)
The target=”_blank” vulnerability by example
Quite an eye opener… You may have read about this over the last few months but seeing an example sure does get you thinking. (dev.to)
How To Use WebPageTest and its API
This article looks into using the WebPageTest RESTful API to extract vital information so you can optimise the performance of your site via a build script or the likes. (css-tricks.com)
The cost of small modules
Including countless little modules throughout a codebase is becoming increasingly popular in todays JavaScript landscape, but is that the best for performance? Nolan Lawson gets his testing hat on and explores some interesting stats. (nolanlawson.com)
How Spotify’s website UX has changed
Sean Hervo looks into how Spotify’s website design has changed over the last decade (a lot!). A good trip down memory lane. (blog.prototypr.io)
Design Better Data Tables(medium.com)
Tools / Resources
Offline Content with Service Workers
If you are thinking about implementing service workers this post offers some great advice in an easy digestible manner. (madebymike.com.au)
Using Feature Queries in CSS
Jen Simmons explains how you can go about writing your CSS with the latest features by utilising the simple @supports rule. (hacks.mozilla.org)
Visualization with React
A 7 part series put together by Jerome Cukier that looks into creating visualizations with React. The series starts off quite basic but ends up dissecting a complex visualization with live data and several components interacting with one another. (jeromecukier.net)
Great list of React/JSX patterns with examples (reactpatterns.com)
Initial release of Jekyll Admin is out (github.com)
Remote retrospectives with Retrobot (remysharp.com)
Inspiration
React Game- Elephant Taco Hunt (codepen.io)
Faster and More Accessible Digital Ocean (digitalocean.com)
CascadiaFest 2016 Videos (youtube.com)
Jobs
Product Designer at Zapier
We’re looking for a Product Designer to join the design team at Zapier. Want to create meaningful experiences that help people automate their tedious, everyday tasks so they spend less time working extra hours, and more time enjoying what matters most to them? (zapier.com)
Head of Design at Vimeo
If you are keen to oversee all product design and user experience, achieving both business and product goals. Take ownership of the look and feel for the web and all native Vimeo apps on mobile phones, tablets, televisions we want to hear from you. (vimeo.com)
Need to find passionate developers or designers? Why not advertise in the next newsletter
Last but not least…
Front End Center — Screencasts for Web Professionals (frontend.center)
The State of JavaScript (stateofjs.com)
The post Web Design Weekly #250 appeared first on Web Design Weekly.
by Jake Bresnehan via Web Design Weekly
Versioning Show, Episode 6, with Jen Simmons
In this episode, Tim and David are joined by Jen Simmons, Designer Advocate at Mozilla, award-winning podcaster and regular conference presenter. They discuss the future of CSS layouts with grids, regions and @supports, being a rebel with a cause in the workplace, and inventing French fry cheeseburgers with Houdini.
Continue reading %Versioning Show, Episode 6, with Jen Simmons%
by M. David Green via SitePoint
4 Agile Ways to Handle Bugs in Production
In a perfect world, every time we rolled out code at the end of a sprint, it would work perfectly in production. There would never be any bugs, and there would never be any issues that forced us to roll back code that has already been deployed.
Of course, we don't live in a perfect world. That's one of the reasons why we have agile in the first place. Agile isn't about pretending that your world is perfect. It's about adapting to reality, and iterating to improve your processes and your flexibility so that when problems arise you're able to deal with them.
One of the problems that comes up frequently for teams is the discovery of a new bug in production right in the middle of a sprint. Your team has finished deploying, all the tests passed, and everything has been pushed out to production so customers can start using it.
But maybe an edge case that wasn't considered comes up. Maybe some aspect of the code that wasn't fully tested comes to the surface, and starts causing problems for users. How's your agile team supposed to respond to that?
There are many different approaches to dealing with bugs in production that come up during a sprint. Choosing the one that works best for your team is dependent on how your company is structured, how critical the bug is, and what matters most to your product owner and your customer.
The Minimal Impact Option
If a bug in production is the result of a previous sprint's work, and it's having a negative effect on users, the simplest thing to do whenever possible is to roll back the production server to the state that it was in before it was updated after the last sprint. At the very least, this will minimize the impact of the bug on new users.
Doing this requires having a production deployment system setup that supports clean rollbacks. An agile team with the ability to push code into production should ideally be working in an environment that supports continuous deployment, or at the very least deployment tags that allow you to roll back your production servers to a previous state. It's times like this that you really appreciate having strong deployment or devops engineers on the team.
If it's possible to solve the problem that simply, the product owner may choose to write a bug story to be worked on in the next sprint. That will prevent this current sprint from being interrupted, and reduce the impact on the team's velocity. Handling bugs this way also allows the team to consider more carefully the potential impact of the bug, and the best way to fix it.
The Deep Exploration Option
Sometimes fixing a bug in production isn't as simple as it sounds. For example, the bug could have had an effect on the data being entered into the application, or the bug may actually exist in the data layer. In this case, database recovery may be necessary, which introduces a whole range of other difficulties.
Recognizing the potential scope of a bug is the responsibility of the product owner in concert with the engineering team. When a bug is discovered, it may be necessary for the product owner to pull one or more engineers into meetings to discuss the depth of the impact and make a plan of action. Of course, the team's velocity in the sprint will likely be reduced merely because of the need to assess the extent of the damage and propose a viable solution.
If the bug is urgent enough and the prognosis is uncertain, it may be necessary to introduce a new spike within the current sprint, and have somebody on the engineering team start looking ahead toward what's going to be necessary to fix the bug in the next sprint. Bugs can be difficult to estimate because of their unknown nature, and it's usually a good idea not to assign points to a bug for that reason. However, having one engineer take away a little bit of effort from the current sprint can pay off in the long run, without holding back the whole team.
The Urgent Effort Option
It's not always possible to put off a bug fix until the next sprint. Sometimes a bug is so critical, and affects such an important aspect of the product, that it's necessary to implement a fix during the current sprint. Ideally, this effort won't require the entire development team. It's the product owner's responsibility to assess the scope of the damage, and decide whether it's worth introducing a new story in the middle of a sprint to address a critical bug.
Introducing new stories in the middle of a sprint is never a good idea. A good scrum master should work with the product owner to try to limit changes to a sprint that's in progress. But that doesn't mean that it's never necessary, and a good scrum master should also be able to communicate clearly to the team when and why it's important to adjust the backlog if that's the best option.
The goal in this case is to have as small an impact on the sprint as possible. Perhaps the developers who worked on the section of code that is causing the problems can be pulled off of the stories they're working on, and temporarily assigned to fix the bug. Of course, any stories they're working on will suffer, and there won't be any points earned in the sprint for work done on a bug from a previous sprint.
The Nuclear Option
If a critical bug is discovered in production code, the presence of the bug is causing serious problems, and more than half of the development team is needed to work in concert to fix it, sometimes the only thing to do is to stop the sprint and start a new one.
Continue reading %4 Agile Ways to Handle Bugs in Production%
by M. David Green via SitePoint
Subscribe to:
Posts (Atom)