Warning: Table './devblogsdb/cache_page' is marked as crashed and last (automatic?) repair failed query: SELECT data, created, headers, expire, serialized FROM cache_page WHERE cid = 'http://www.softdevblogs.com/?q=aggregator&page=2' in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc on line 135

Warning: Cannot modify header information - headers already sent by (output started at /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc:135) in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/bootstrap.inc on line 729

Warning: Cannot modify header information - headers already sent by (output started at /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc:135) in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/bootstrap.inc on line 730

Warning: Cannot modify header information - headers already sent by (output started at /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc:135) in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/bootstrap.inc on line 731

Warning: Cannot modify header information - headers already sent by (output started at /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc:135) in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/bootstrap.inc on line 732
Software Development Blogs: Programming, Software Testing, Agile, Project Management
Skip to content

Software Development Blogs: Programming, Software Testing, Agile Project Management

Methods & Tools

Subscribe to Methods & Tools
if you are not afraid to read more than one page to be a smarter software developer, software tester or project manager!

Feed aggregator
warning: Cannot modify header information - headers already sent by (output started at /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/database.mysql.inc:135) in /home/content/O/c/n/Ocnarfparking9/html/softdevblogs/includes/common.inc on line 153.

Chrome Dev Summit 2015: That’s a wrap!

Google Code Blog - Thu, 11/19/2015 - 01:05

Originally posted on Chromium Blog

Posted by Darin Fisher, VP Engineering, Chrome

The last sessions of the Chrome Dev Summit 2015 are coming to a close, so it’s the perfect time to reflect on the event. We started our annual summit back in 2012, where we first introduced Chrome on Android. Today, there are more than 800 million monthly active users on Chrome for Android.
The greatest power of the Web is in its reach—not just across devices and operating systems, but in reaching users. Top mobile web properties are seeing 2.5 times the number of monthly unique visitors compared to the top mobile apps, and mobile web reach is growing at more than twice the rate of mobile app reach. This reach offers a unique opportunity to engage with more users.  
We believe this is a pivotal moment for the web platform, as early adopters of a set of key enabling technologies and tools are seeing success. During the keynote, we covered the evolution of the mobile platform and the shift towards “progressive web apps,” which are fast, robust, app-like experiences built using modern web capabilities. The web has come a long way, and building immersive apps with web technology on mobile no longer requires giving up properties of the web you’ve come to love. Flipkart’s new mobile web experience is a great example of a progressive web app that uses the new capabilities to provide a next-generation user experience.

In practice, progressive web apps have three main aspects that separate them from traditional websites: reliability, performance, and engagement.

ReliabilityEvery web app should load quickly, regardless of whether a user is connected to fast Wi-Fi, a 2G cell network, or no connection at all. We envision service workers as the ideal way for developers to build web apps that are resilient despite changing and unreliable networks. We've released two libraries to help take the work out of writing your own service worker: sw-precache and sw-toolbox for your App Shell and dynamic content, respectively. Once your implementation is up and running, you can easily test it on different network connections using Chrome DevTools and WebPageTest. Service workers are already seeing great adoption by developers: there are currently 2.2 billion page loads a day using service workers, not counting its use in the New Tab page in Chrome.
PerformanceThe RAIL performance model helps you figure out what a user expects from each interaction with your site or app, breaking down performance into four key goals: 
  • Responses (tap to response) should be less than 100ms 
  • Animations (scrolling, gestures, and transitions) should run at 60 frames per second
  • Idle time should be used to opportunistically schedule non-essential work in 50ms chunks
  • Loading should be finished in under 1 second

In practice, we've found improving even just one area of RAIL performance can make a dramatic difference on the user experience. For example, a one second difference in loading time can have as much as an 11% impact on overall page views and a 16% impact on customer satisfaction.
EngagementTraditionally, users have had a hard time re-engaging with sites on the web. Push notifications enable you to build experiences that users can engage with "outside of the tab"--they don’t need to have the browser open, or even be actively using your web app, in order to engage with your experience. Best of all, these notifications appear just like other app notifications. Currently we’re seeing over 350 million push notifications sent every day in Chrome, and it’s growing quickly. Beyond the Rack has found that users arriving to their site by push notifications browse 72% longer than average users and spend 26% more.
Tools for SuccessFinally, Google is committed to making web developers successful. As our generalized library for building components on the web, Polymer is also deeply focused on helping developers achieve RAIL. Since its 1.0 release at Google I/O earlier this year, it has grown to be used on over 1 million web pages, including more than 300 projects within Google. Polymer 1.0 was 3 to 4 times faster than the previous 0.5 version, and the latest 1.2 release is even 20% faster than that. To get started with this modern way of thinking about web development, take a quick tour of Polymer, watch the Polymer Summit talks, check out the Polymer codelabs, or try the Polymer Starter Kit.
We already have great resources like Web Fundamentals that we continue to expand and improve.  We’re also committed to documenting each new feature we ship on the Mozilla Developer Network. In the past year alone, we’ve made 2,800 individual edits to MDN and created 212 new pages. To further our commitment to educating web developers, we’ve partnered with Udacity to offer a senior web nanodegree, an education credential focused on modern web technologies and techniques like service workers, Promises, HTTP/2 and more.
For all the details on Chrome Dev Summit 2015, you can watch full session videos, which we will continue to upload as they’re ready. Thanks for coming, thanks for watching, and most of all, thank you for developing for the web!
Categories: Programming

Hungering for Game Utilities?

Google Code Blog - Wed, 11/18/2015 - 21:58

Posted by Alex Ames, Fun Propulsion Labs*

At Fun Propulsion Labs we spend some of our time building sample games to help demonstrate how to make easy-to-build, performant, cross-platform games. With the growth of Google Cardboard, we got to work and over many long evenings, feeding our animal hunger on sushi, we came up with Zooshi. Zooshi is an open source, cross-platform game written in C++ which supports:

  • Android, Android TV, Windows, OSX, and Linux
  • Google Cardboard
  • Google Play Games Services sign-in and leaderboards on Android
  • Level customization

Zooshi serves as a demonstration of how to build Android games using a suite of newly released and updated open source game technologies from Google:

  • Motive drives our Animation system, giving life and movement to the characters and environment.
  • CORGI, the Component Oriented Reusable Game Interface, is an Entity-Component system designed to allow users to define complicated game objects as collections of modular, custom-defined behaviors.
  • FlatUI is a straightforward immediate mode GUI system with a light footprint that makes building up user interfaces a breeze.
  • Scene Lab allows designers to design levels and edit entities from right in the game without needing to use an external editor.
  • Breadboard provides an easy to use node based scripting system for editing entity behaviors that's accessible to designers without deep knowledge of programming.
  • FPLBase is a cross-platform API layer, for abstracting low-level tasks like reading input and creation of graphical contexts.

As in our previous release, Pie Noon, we also made extensive use of Flatbuffers, Mathfu, fplutil, and WebP.

You can download the game in the Play Store and the latest open source release from our GitHub page. We invite you to learn from the code to see how you can apply these libraries and utilities in your own Android games. Take advantage of our discussion list if you have any questions, and don’t forget to toss some sushi around while you’re at it!

* Fun Propulsion Labs is a team within Google that's dedicated to advancing gaming on Android and other platforms.

Categories: Programming

API 23 SDK now available for Android Wear

Android Developers Blog - Wed, 11/18/2015 - 19:12

Posted by Wayne Piekarski, Developer Advocate

The new LG Watch Urbane 2nd Edition LTE is the first watch to run Android 6.0 Marshmallow (API 23) for Android Wear. Currently, all other Android Wear watches implement API 22, and in the coming months, these will receive an OTA update for API 23 as well.

So what does this mean for you as an Android Wear developer? You will need to ensure that your apps are compatible with both API 23 and API 22 watches. While you can start implementing the new features in this post, you still need to maintain backwards compatibility until all watches are upgraded.

New permissions model and samples

API 23 introduces a new runtime permissions model for both phones and watches. The new permissions model allows users to pick and choose which permissions to grant apps at the time of use. In addition, new permissions settings allow users to turn on and off app permissions at any time.

To use the new permissions model on Wear, read Permissions on Android Wear. This training guide provides an in-depth discussion of Wear-specific scenarios, such as when your Wear app relies on a phone-side permission. In addition, all of the Android Wear samples have been updated to use the new permissions model, and a new RuntimePermissionsWear sample shows how to handle permission requests across devices.

When you are ready, you can update your application on both the phone and watch side to use compileSdkVersion 23 and targetSdkVersion 23. Make sure that you check and request the permissions needed by your app at runtime, on both the phone and the watch. It is important that you do not change targetSdkVersion to 23 until you have implemented the permission checks properly, since it changes how the system installs and runs the app. For example, an API call that might have previously returned a result could now fail, causing the app to behave in unexpected ways.

-round and -notround resource qualifiers

API 23 makes it easier to build apps for both round and square Android Wear watches. We listened to your feedback and added new resource qualifiers for -round and -notround, so you can use the resource system to load the appropriate images, layouts, and strings based on the type of watch you are working with. You can also combine this with existing resource qualifiers -hdpi, -tvdpi, -280dpi, and -360dpi for the various Android Wear watches that are currently available. All of the existing classes in the wearable UI library, such as WatchViewStub, BoxInsetLayout, and WearableFrameLayout will continue to work as well, so you do not need to change your code. The -round and -notround resource qualifiers will not work on API 22 devices, so you cannot assume they will be available until all devices are on API 23.

Watches with speakers

The LG Watch Urbane 2nd Edition LTE is the first watch to include speaker support, so you can now add sounds to your Wear app. You can play audio files using the same APIs that are available on Android phones, such as AudioTrack, MediaPlayer, and ExoPlayer. Check out the sample and documentation to learn how to detect when the speaker is available on a Wear device and play sounds through it.

Intel x86 support

The new TAG Heuer Connected, along with other upcoming Android Wear watches, is based on Intel x86 processors. If you are working only with Java code, your apps will automatically work on any architecture. However, if you’re using the NDK, you’ll need to provide both armeabi-v7a and x86 shared libraries in your wearable APK. Since only one wearable app can be bundled in a phone app, it is not possible to deliver different APKs to different watches based on architecture. If your wearable APK is missing an x86 library, it will fail to install on x86 watches with INSTALL_FAILED_NO_MATCHING_ABIS and code -113.

If you are using Android Studio, you will need to adjust your build.gradle file to include:

ndk {
  abiFilters = ['armeabi-v7a','x86']

If you are using the NDK directly, you will need to modify your Application.mk file to use:

APP_ABI := armeabi-v7a x86

These changes should only be made for the wearable APK, and you can continue to support other ABIs on the phone side. You can test your application by checking if it works on the x86 emulator provided by the SDK Manager.

Updated emulator

New Android Wear emulator images for API 23 and x86 watches are available to download from the SDK Manager in Android Studio. We have also added profiles that represent every available Android Wear watch, so you can easily test on any device you want. It is also important that you understand and test all the combinations of phones (API <= 22, API = 23) and wearables (API 22, API 23), so that your app works for all users.

Updates to existing watches

The new emulator images allow you to get started immediately with testing and deploying updated apps for users with API 23 watches. The schedule for updating existing Android Wear watches via OTA updates has not been announced yet. We will announce the update schedule on the Android Wear Developers Google+ community. We’ll also let you know when the rollout is complete, and API 22 support for Android Wear is no longer needed.

Categories: Programming

Free Book: Practical Scalablility Analysis with the Universal Scalability Law

If you are very comfortable with math and modeling Dr. Neil Gunther'Universal Scalability Law is a powerful way of predicting system performance and whittling down those bottlenecks. If not, the USL can be hard to wrap your head around.

There's a free eBook for that. Performance and scalability expert Baron Schwartz, founder of VividCortex, has written a wonderful exploration of scalability truths using the USL as a lens: Practical Scalablility Analysis with the Universal Scalability Law

As a sample of what you'll learn, here are some of the key takeaways from the book:

  • Scalability is a formal concept that is best defined as a mathematical function.
  • Linear scalability means equal return on investment. Double down on workers and you’ll get twice as much work done; add twice as many nodes and you’ll increase the maximum capacity twofold. Linear scalability is oft claimed but seldom delivered.
  • Systems scale sublinearly because of contention, which adds queueing delay, and crosstalk, which inflates service times. The penalty for contention grows linearly and the crosstalk penalty grows quadratically. (An alternative to the crosstalk theory is that longer queues are more costly to manage.)
  • Contention causes throughput to asymptotically approach the reciprocal of the serialized fraction of the workload. If your workload is 5% serialized you’ll never grow the effective speedup by more than 20-fold
  • Crosstalk causes the system to regress. The harder you try to push systems with crosstalk, the more time they spend fighting amongst themselves.
  • To build scalable systems, avoid contention (serialization) and crosstalk (synchronization). The contention and crosstalk penalties degrade system scalability and performance much faster than you’d think. Even tiny amounts of serialization or pairwise data synchronization cause big losses in efficiency.
  • If you can’t avoid crosstalk, partition (shard) into smaller systems that will lose less efficiency by avoiding the explosion of service times at larger sizes.
  • To model systems with the USL, obtain measurements of throughput at various levels of load or size, and use regression to estimate the parameters to Equation 3.
  • To forecast scalability beyond what’s observable, be pessimistic and treat the USL as a best-case scenario that won’t really happen. Use Equation 4 to forecast the maximum possible throughput, but don’t forecast too far out. Use Equation 6 to forecast response time.
  • Use your judgment to predict limitations that USL can’t see, such as saturation of network bandwidth or changes in the system’s model when all of the CPUs become busy
  • Use the USL to explain why systems aren’t scaling well. Too much queueing? Too much crosstalk? Treat the USL as a pessimistic model and demand that your systems scale at least as well as it does.
  • If you see superlinear scaling, check your measurements and how you’ve set up the system under test. In most cases σ should be positive, not negative. Make sure you’re not varying the system’s dimensions relative to each other and creating apparent superlinear efficiencies that don’t really exist.
  • It’s fun to fantasize about models that might match observed system behavior more closely than the USL, but the USL arises analytically from how we know queueing systems work. Invented models might not have any basis in reality. Besides, the USL usually models systems extremely well up to the point of inflection, and modeling what happens beyond that isn’t as interesting as knowing why it happens.
  • Never trust a scatterplot with an arbitrary curve fit through it unless you know why that’s the right curve. Don’t confuse the USL, hockey stick charts from queueing theory, or other charts that just happen to have similar shapes. Know what shape various plots should exhibit, and suspect bad measurements or other mistakes if you don’t see them.

Note, the link to the eBook requires entering some data, but it's free, well written, and useful, so it's probably worth it.

Related Articles
Categories: Architecture

Chrome Dev Summit Livestream 2015 - Day 2

Google Code Blog - Wed, 11/18/2015 - 17:50

Posted by Paul Kinlan, Chrome Developer Relations

Welcome to day two of the Chrome Dev Summit livestream 2015! Today, we’ll have a full day of sessions covering every aspect of performance on the web. Flipkart will also be joining us on stage later today to talk about their experience building a Progressive web app. Tune in to the livestream below. We look forward to engaging in the conversation with you at #ChromeDevSummit.

Categories: Programming

Teach the World Your Experience in a Mobile-First, Cloud-First World

“Be steady and well-ordered in your life so that you can be fierce and original in your work.”  -- Gustave Flaubert

An important aspect of personal effectiveness and career development is learning business skills for a technology-centric world.

I know a lot of developers figuring out how to share their expertise in a mobile-first, cloud-first world.  Some are creating software services, some are selling online courses, some are selling books, and some are building digital products.    It’s how they are sharing and scaling their expertise with the world, while doing what they love. 

In each case, the underlying pattern is the same:

"Write once, share many." 

It’s how you scale.  It’s how you amplify your impact.  It’s a simple way to combine passion + purpose + profit.

With our mobile-first, cloud-first world, and so much technology at your fingertips to help with automation, it’s time to learn better business skills and how to stay relevant in in an ever-changing market.   

But the challenge is, how do you actually start?

On the consumer side ...
In a mobile-first, cloud-first world, users want the ability to consume information anywhere, anytime, from any device.

On the produce side ...
Producers want the ability to easily create digital products that they can share with the world -- and automate the process as much as possible. 

I've researched and tested a lot of ways to share your experience in a way that works in a mobile-first, cloud-first world.  I’ve went through a lot of people, programs, processes, and tools.  Ultimately, the proven practice for building high-end digital products is building courses.  And teaching courses is the easiest way to get started.  And Dr. Cha~zay is one of the best in the world at teaching people how to teach the world what they love.

I have a brilliant and deep guest post by Dr. Cha~zay on how to teach courses in a mobile-first, cloud-first world:

Teach the World What You Love

You could very much change your future, or your kid’s future, or your friend’s future, or whoever you know that needs to figure out new ways to teach in a mobile first, cloud-first world.

The sooner you start doing, testing, and experimenting, the sooner you start figuring out what works in a Digital Economy could mean to you, your family, your friends, in a mobile-first, cloud-first world.

The world changes. 

Do you?

Categories: Architecture, Programming

What I Wished I Knew Before I Jumped Into iOS – Part I

Making the Complex Simple - John Sonmez - Wed, 11/18/2015 - 14:00

Earlier this year, Nikhant Vohra of Paypal told of the things he wished he knew before he dove into iOS development. In his article, Vohra focuses on what development tools and blogs he wished he knew of before he began iOS Development. My hope is to give you what I feel is the other half […]

The post What I Wished I Knew Before I Jumped Into iOS – Part I appeared first on Simple Programmer.

Categories: Programming

Docker to the on-premise rescue

Xebia Blog - Wed, 11/18/2015 - 10:18

During the second day at Dockercon EU 2015 in Barcelona, Docker introduced the missing glue which they call "Containers as a Service Platform". With both focus on public cloud and on-premise, this is a great addition to the eco system. For this blogpost I would like to focus on the Run part of the "Build-Ship-Run" thought of Docker, and with the focus on on-premise. To realize this, Docker launched the Docker Universal Control Plane which was the project formerly known as Orca.

caas-private I got to play with version 0.4.0 of the software during a hands-on lab and I will try to summarize what I've learned.

Easy installation

Of course the installation is done by launching Docker containers on one or more hosts, so you will need to provision your hosts with the Docker Engine. After that you can launch a `orca-bootstrap` container to install, uninstall, or add an Orca controller. The orca-bootstrap script will generate a Swarm Root CA, Orca Root CA, deploy the necessary Orca containers (I will talk more about this in the next section), after which you can login into the Docker Universal Control Plane. Adding a second Orca controller is as simple as running orca-bootstrap with a join parameter and specifying the existing Orca controller.


Let's talk a bit about the technical parts and keep in mind that I'm not the creator of this product. There are 7 containers running after you have succesfully run the orca-bootstrap installer. You have the Orca controller itself, listening on port 443, which is your main entry point to Docker UCP. There are 2 cfssl containers, one for Orca CA and one for Swarm CA. Then you have the Swarm containers (Manager and Agent) and the key-value store, for which Docker chose etcd. Finally, there is an orca-proxy container, whose port 12376 redirects to the Swarm Manager.  I'm not sure why this is yet, maybe we will find out in the beta.

From the frontend (which we will discuss next) you can download a 'bundle', which is a zip file containing the TLS parts and a  sourceable environment file containing:

export DOCKER_CERT_PATH=$(pwd)
export DOCKER_HOST=tcp://orca_controller_ip:443
# Run this command from within this directory to configure your shell:
# eval $(env.sh)
# This admin cert will also work directly against Swarm and the individual
# engine proxies for troubleshooting.  After sourcing this env file, use
# "docker info" to discover the location of Swarm managers and engines.
# and use the --host option to override $DOCKER_HOST

As you can see, it also works directly against Swarm manager and Engine to troubleshoot. Running `docker version` with this environment returns:

Version:      1.9.0
API version:  1.21
Go version:   go1.4.2
Git commit:   76d6bc9
Built:        Tue Nov  3 17:43:42 UTC 2015
OS/Arch:      linux/amd64
Version:      orca/0.4.0
API version:  1.21
Go version:   go1.5
Git commit:   56afff6
OS/Arch:      linux/amd64


Okay, so when I opened up the frontend it looked pretty familiar and I was trying to remember where I've seen this before. After a look at the source, I found an ng-app parameter in the html tag named shipyard. The GUI is based on the Shipyard project, which is cool because this was an already well functioning management tool built upon Docker Swarm and the Docker API, so people familiar with shipyard already know the functionality, so let me quickly sum up what it can do and wthat it looks like in Docker UCP.

ducp-dashboardDashboard overview

ducp-applications2Application expanded, quickly start/stop/restart/destroy/inspect running container

ducp-applications-applicationApplication overview, graphs of resource usage and container IDs can be included or excluded from the graph.

ducp-containersContainers overview, multi select containers and execute actions

ducp-containers-container-logsAbility to quickly inspect logs

ducp-contaienrs-container-consoleAbility to exec into the container to debug/troubleshoot etc.

Secrets Management & Authentication/Authorization

So, in this hands-on lab there were a a few things that were not ready yet. Eventually it will be possible to hook up Docker UCP to an existing LDAP directory but I was not able to test this yet. Once fully implemented you can hook it up to your existing RBAC system and give teams the authorization they need.

There was also a demo showing off a secret management tool, which also was not yet available. I guess this is what the key-value store is used for as well. Basically you can store a secret at a path such a secret/prod/redis and then access it by running a container with a label like:

docker run -ti --rm -label com.docker.secret.scope=secret/prod

Now you can access the secret within the container in the file /secret/prod/redis.

Now what?

A lot of the new things are being added to the ecosystem, which is certainly going to help the adoption of Docker for some customers and bringing it into production. I like that Docker thought of the on-premise customers and deliver them an equally as the cloud users. As this is an early version they need feedback from users, so if you are able to test it, please do so in order to make it a better product. They said they are already working on multi-tenancy for instance, but no timelines were given.

If you would like to sign up for the beta of Docker Universal Control Plane, you can sign up at this page: https://www.docker.com/try-ducp



Done and Value Are Related!


                                                        A short sprint

In recent exchange after the 16th installment of the re-read Saturday of the Mythical Man-Month, Anteneh Berhane called me to ask one of the hardest questions I had ever been asked: why doesn’t the definition of done include value? At its core, the question was asks how can we consider work “done”, if there is no business value delivered, even if the definition of done is satisfied including demonstrably meeting acceptance criteria. Is software are really done if the business need has changed so what was delivered is technically correct, but misses the mark based on the business environment today? This is a scenario I was all to familiar with during the 1980s and 1990s at the height of large waterfall projects but see less in today’s Agile development environment.  Anteneh Berhane’s question reminds us that the problem is still possible.  We discussed five potential problems that disrupt the linkage between done and value.  Today we will discuss the first two and Thursday the next set.

An incredibly dynamic business environment can be a huge contributor to the potential of delivering software that does not have value (or the anticipated value).  Conceptually this is the simplest contributor to develop an understanding of, but nearly impossible to solve. The good news is that in a typical business environment this problem rarely occurs. Whole business environments rarely change in a week or two weeks. This problem is more apt to be seen on battlefields and in sporting events.  In these scenarios, business needs may evolve so quickly so that the original short-term acceptance criteria may not be translated to value. Continuous planning/re-planning and delivery techniques such as Kanban are potential solutions. Planning and testing continuously generate the feedback need to stay on track.

Long sprints can be a mechanism that irrationally perpetuates the waterfall cycle.  One of the first time boxes proposed by Champy (Champy and Hammer, Reengineering the Corporation, 1993 revised 2006) in the 1990s was delivering every 90 days.  In those 90 days, you could easily do a small waterfall story.  In today’s Agile, a typical sprint/iteration is 2 weeks or 10 business days; which, as we have noted, tends to make sure the world does not change too much.  However, there are still organizations with month-long (or longer) iterations. The longer the sprint the higher the probability that the business need will change. The simplest fix for this type of problem is to reduce the duration of the sprint to a time frame where functionality can be delivered that meets the business needs.

Categories: Process Management

Minimum purchase price for apps and in-app products reduced on Google Play

Android Developers Blog - Tue, 11/17/2015 - 22:38

Posted by Alistair Pott, Product Manager, Google Play

Available in more than 190 countries, Google Play is a global platform for developers to build high quality apps and successful businesses. But every market has its own unique challenges and opportunities. Purchasing behavior, in particular, varies significantly between markets. So to provide developers with more flexibility, we've worked to adapt Google Play pricing options to better suit local consumers and make content more accessible.

Following a successful pilot in India earlier this year, today, developers have the option to reduce the price of their premium titles and in-app products in 17 more countries to these new minimum thresholds:

Countries affected:

  • Brazil: R$ 0.99 (was R$2.00)
  • Chile: CLP $200.00 (was CLP $500.00)
  • Colombia: COP$ 800.00 (was COP$ 2000.00)
  • Hungary: Ft 125.00 (was Ft 225.00)
  • Indonesia: Rp 3,000.00 (was Rp 12,000.00)
  • Malaysia: RM 1.00 (was RM 3.50)
  • Mexico: MXN$ 5.00 (was MXN$ 9.90)
  • Peru: S/. 0.99 (was S/. 3.00)
  • Philippines: ₱15.00 (was ₱43.00)
  • Poland: zł1.79 (was zł2.99)
  • Russia: руб 15.00 (was руб 30.00)
  • Saudi Arabia:﷼ 0.99 (was 4.00﷼)
  • South Africa: R3.99 (was R10.00)
  • Thailand: ฿10.00 (was ฿32.00)
  • Turkey: ₺0.59 (was ₺2.00)
  • Ukraine: ₴5.00 (was ₴8.00)
  • Vietnam: ₫6,000 (was ₫21,000.00)

You can lower the price of your apps and games right away by visiting the Google Play Developer Console and clicking on “Pricing & Distribution” or “In-app Products” for your apps.

We hope this change allows you to reach more people around the world so that you can continue to grow your business on Google Play.

Categories: Programming

Introducing the Senior Web Developer Nanodegree Program with Udacity

Google Code Blog - Tue, 11/17/2015 - 21:22

Posted by Sarah Clark, Program Manager, Google Developer Training

What do you need to stand out from the crowd of web developers, and ultimately, land that perfect job?

We asked ourselves that same question and decided to help by introducing the Senior Web Developer Nanodegree. Built in collaboration with Udacity, this online program is designed to teach you the tools, frameworks, and techniques needed to write robust code for progressive web applications that are secure and easy to use. Spending about 10 hours a week, most students can earn this Nanodegree credential in 9-12 months at a cost of $200 per month with 50% returned upon completion.

Along the way, you will also learn how to integrate new technologies, such as Service Worker and Web Components, and work extensively with Gulp and other tools. You’ll hear from Google experts, such as Ido Green, Jake Archibald (co-author of the Service Worker spec), Luke Wroblewski (author and strategist), Paul Bakaus (Studio 5 CTO, Zynga) and Alice Boxhall (author of the Chrome accessibility developer tools).

How can you get started? There are two different ways to participate. One option is the paid Nanodegree program, which includes code-level project reviews and feedback, coaching, support from a cohort of peers, building a portfolio of work, and career support services. The second option is entirely free and includes the same instructional courses, quizzes and projects individually, which you can take at your own pace.

For more details, and to be notified when enrollment opens, check out udacity.com/googlewebdev.

Categories: Programming

An updated app guide and new video tips to help you find success on Google Play

Android Developers Blog - Tue, 11/17/2015 - 19:15

Posted by Dom Elliott, The Google Play Apps & Games team

Last year, we introduced our first playbook for developers, “The Secrets to App Success on Google Play”, to help you grow your app or game business, which has been downloaded more than 200,000 times.. Many new features have since been announced on the platform – from Store Listing Experiments and beta testing improvements to App Invites and Smart Lock for Passwords.

Get the second edition of “The Secrets to App Success on Google Play”

Hot off the press, you can now download the second edition to learn about all the new tools and best practices for improving the quality of your app, growing a valuable audience, increasing engagement and retention, and earning more revenue.

Get the book on Google Play in English now or you can sign-up to be notified when the booklet is released in the following languages: Bahasa Indonesia, Deutsch, español (Latinoamérica), le français, português do Brasil, tiếng Việt, русский язы́к, ไทย, 한국어, 中文 (简体), 中文 (繁體), 日本語. Based on your feedback, the guide was updated to work seamlessly in the Google Play Books app. If you prefer, you can also download a PDF version from the Android Developers website.

New videos with tips to find success on Google Play

To accompany the guide, watch the first two episodes in a new ten-part video series of actionable tips you can start using today to achieve your business objectives. Subscribe to the Android Developers channel on YouTube and follow +Android Developers to watch the new videos as they’re released weekly.

Two new videos will be released each week in the ten-part series
on the Android Developer YouTube channel.

Let us know your feedback

Once you’ve checked out the guide and the videos, we’d again love to hear your feedback so we can continue to improve our developer support, please let us know what you think.

Categories: Programming

Chrome Dev Summit Livestream 2015 - Day 1

Google Code Blog - Tue, 11/17/2015 - 17:54

Posted by Paul Kinlan, Chrome Developer Relations

Welcome to the Chrome Dev Summit livestream 2015! Today, Darin Fisher, VP of Chrome, has some exciting announcements and will speak about how the Chrome team is thinking about the future of the web. Tune in to the livestream below. We look forward to engaging in the conversation with you at #ChromeDevSummit.

Categories: Programming

Leave Work Unassigned and See Who Steps Forward

Mike Cohn's Blog - Tue, 11/17/2015 - 16:00

Create vacuums and then see who steps in to fill them

Early in my career, I noticed the project managers in my company drove nicer cars than we programmers did. (This was back before companies had learned to fully value their technical staff.) After a few years of noticing those nicer cars, I asked my boss what I needed to do to become a project manager. He told me, "When you start acting like a manager, I'll make you a manager."

This advice wasn't unique to him. I've since heard it from many other bosses. And it's actually not bad advice.

The problem with my boss's advice was that there were no opportunities for me to start acting like a manager. Each of the company's projects already had a project manager assigned to it. If I had started acting like the manager of a project that already had a manager, the officially appointed manager would have been quite annoyed with me.

If my boss had really wanted me to start acting like a manager in order for him to promote me into that role, he should have left a void in the organization for me to fill. In fact, an important part of a leader's job in an agile organization is to create vacuums so that the right people can step forward and fill them.

Creating a vacuum entails deliberately leaving a gap in an organization. Rather than filling the gap by identifying a specific person or group of people to fill it, a leader can point out the gap, and then see what happens. The benefit of this approach is that it allows people to work in areas where they are passionate.

As an example, many years ago, I was working as a VP of software development. Some of the first XP teams in that company discovered the benefits of continuous integration, and I was excited to spread this practice across the department. I could have appointed someone to make that happen.

Instead, at the next department meeting, I talked about how impressed I was with what those teams had done, and how it was going to be important for us to spread that good practice to other teams. Without explicitly saying so, I let it be known that this was something people could work on.

Of course, for this to work, leaders also need to create a culture in which employees do not have every waking moment of every day committed to project work. Companies don't need to go so far as the well-known Google 20 percent time, but employees should generally have some time they devote to work of their own choosing.

This is a sign that leaders trust employees. It is also a recognition that it is impossible for a leader or manager to identify the highest priority work in all cases.

If you're a leader in an agile organization, the next time you need something done, rather than assigning someone to the work, consider creating a vacuum and seeing who steps into it.

Why I like golang: a programming autobiography

Agile Testing - Grig Gheorghiu - Mon, 11/16/2015 - 19:07
Tried my hand at writing a story on Medium.

9ish Low Latency Strategies for SaaS Companies

Achieving very low latencies takes special engineering, but if you are a SaaS company latencies of a few hundred milliseconds are possible for complex business logic using standard technologies like load balancers, queues, JVMs, and rest APIs.

Itai Frenkel, a software engineer at Forter, which provides a Fraud Prevention Decision as a Service, shows how in an excellent article: 9.5 Low Latency Decision as a Service Design Patterns.

While any article on latency will have some familiar suggestions, Itai goes into some new territory you can really learn from. The full article is rich with detail, so you'll want to read it, but here's a short gloss:

Categories: Architecture

Creating Great Estimates as a Team

I’ve been teaching workshops these last few weeks. A number of the participants think that they need to create great estimates. I keep hearing, “I have to create accurate estimates. My team needs my estimate to be accurate.”

I have found that the smaller the work, the better the estimate. If people work as a team, they can provide more accurate estimates than they can alone. And, if they work as a team, the more likely they are to meet the estimate.

The people in my workshops did not want to hear this. Many of them wanted to know how to create an estimate for “their” work, accounting for multitasking.

I don’t know how to create great estimates when people assume they work alone, or if they multitask.

In all of my experience, software is a team activity (especially if you want to use agile or lean). For me, creating an estimate of “my” work is irrelevant. The feature isn’t done until it’s all done.

When we create solo estimates, we reinforce the idea that we work alone. We can work alone. I have discovered I have different ideas when I pair. That’s one of the reasons I ask for review, if I am not actively pairing. I have also discovered that I find problems earlier when I pair or ask for frequent review. That changes my overall estimate.

Multitasking creates context switching, with built-in delays. (See Cost of Delay Due to Multitasking, Part 2 or Diving for Hidden Treasures.) I don’t know how to account for the context-switch times. For me, the context-switching time varies, and depends on how many switches I need to do.

PredictingUnpredictable-smallIf you want to create great estimates, estimate as a team. For hints, see Predicting the Unpredictable: Pragmatic Approaches to Estimating Project Cost or Schedule.

I urge you to make the thing you estimate small, you consider how you work with other people to deliver this thing, and you do one chunk of work at a time. All of those ideas will help you create better estimates. Not for “your” work, but for the work you deliver to your customer.

Categories: Project Management

Ricardo Barbosa Adds Code While App Is Running

Making the Complex Simple - John Sonmez - Mon, 11/16/2015 - 14:00

Ricardo Barbosa believes that he’s not a “real” entrepreneur only because he works during the day for a telecom company. However, he refers to himself as an entrepreneur at heart, creating product and systems for other developers to do their jobs quickly. He has been a developer on the .NET space and on Microsoft technologies […]

The post Ricardo Barbosa Adds Code While App Is Running appeared first on Simple Programmer.

Categories: Programming

Immutable Principles of Managerial Finance When Spending Other Peoples Money

Herding Cats - Glen Alleman - Mon, 11/16/2015 - 12:57

One of the primary responsibilities of  management is to make decisions during the execution of projects so that gains are maximized and losses are minimized. Decision analysis is critical for projects with built-in flexibility, or options. when these choices operate in the presence of uncertainty. [1]

The notion that we can spend other peoples money in the absence of the immutable principles of Managerial Finance and Microeconomics of decision making pervades the #Noestimates community. Here's a few of those principles to counter that fallacy.

  • We can't determine the value of a software feature or product unless we know the cost to acquire that feature or product. If we determine the value of a feature in our new ERP system is worth $150,000 in savings to us every year. What if to acquire that feature, it costs $50,000 one time and $10,000 a year in maintenance, a typical 20% maintenance charge. That sounds pretty good. But what if to acquire that feature it costs $1,200,000 for a one time charge and $150,000 a year in maintenance? It'll take 80 years to break even not counting the maintenance. This is the principle of cost benefit analysis. And since both the cost and benefit are random variables in the future we'll need to estimate both and construct time phased money to determine the cash flow, sunk cost recovery and benefit flow..

We can't know the benefit until we know the cost to achieve that benefit

  • When we need to make a decision in the presence of uncertainty, and there are multiple choices we need to choose between all of them and pick one. If we know something about the cost of each choice,we can assess the beneficial outcome of that choice. The cost of the choice - that is to acquire a feature - also has a cost of NOT choosing the other choices. This is the opportunity cost between all the choices. This opportunity cost makes visible not only the beneficial outcome of our choice, but the cost of NOT making the other choices.

Microeconomics of decision making in the presence of uncertainty is based on Opportunity costs

  • In any complex software system development domain the usefulness of a precise numerical and analytical approach to make choices breaks down. Resorting to heuristics - empirical assessment of the past, modeling of the future - is not always the best approach, since it's sometimes hard to evaluate the validity of the heuristic because of the informal structure. One approach in this situation is an economics approach that recognizes software efforts expend valuable resources in the presence of an uncertain payoff. This is decision making under uncertainty. Like the Microeconomics of opportunity cost - Real Options is a tool applicable to this problem. We're not trading stock here, but a real options view of capital investments is based on the observation that investment opportunities are similar to a call option that confers upon its holder the right but not the obligation to purchase an asset as a set cost for a period of time. This value seeking approach is called Real Options.

Uncertainty is a central fact of life on most large IT capital investments. Along with uncertainty comes managerial flexibility. A real option refers to the right to obtain the benefits of owning a real world asset without the obligation to exercise that right. 

So in the end, when making a decision - that is selecting from more than one choice - there are several methods listed here. 

Each of these methods of making choices in the presence of uncertainty requires making an estimate of the impact of that choice, an estimate of the cost to acquire the value for the choice, and an estimate of that value. 

 [1] Real Options: The Value Added through Optimal Decision Making, Graziadio Business Review, 

Related articles A Theory of Speculation Architecture -Center ERP Systems in the Manufacturing Domain Making Choices in the Absence of Information
Categories: Project Management

Video: Software architecture as code

Coding the Architecture - Simon Brown - Mon, 11/16/2015 - 12:52

I presented a new version of my "Software architecture as code" talk at the Devoxx Belgium 2015 conference last week, and the video is already online. If you're interested in how to communicate software architecture without using tools like Microsoft Visio, you might find it interesting.

The slides are also available to view online and download. Enjoy!

Categories: Architecture