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

What’s New in Android: O Developer Preview 2 & More

Android Developers Blog - Mon, 05/22/2017 - 07:21

Posted by: Dave Burke, VP of Engineering

android-o-logo.png

With billions of Android devices around the world, Android has surpassed our wildest expectations. Today at Google I/O, we showcased a number of ways we’re pushing Android forward, with the O Release, new tools for developers to help create more performant apps, and an early preview of a project we call Android Go -- a new experience that we’re building for entry-level devices.

Fluid experiences in Android O
It's pretty incredible what you can do on mobile devices today, and how easy it is to rely on them as computers in our pockets. In the O release we've focused on creating fluid experiences that make Android even more powerful and easy to use, and today we highlighted some of those:
  • Picture-in-picture: lets users manage two tasks simultaneously, whether it’s video calling your friend while checking your calendar, or reading a new recipe while watching a video on a specific cooking technique. We’ve designed PIP to provide seamless multitasking on any size screen, and it’s easy for apps to support it.
  • Notification dots extend the reach of notifications, a new way for developers to surface activity in their app, driving engagement. Built on our unique and highly regarded notification system, dots work with zero effort for most apps - we even extract the color of the dot from your icon. 
  • Autofill with Google simplifies setting up a new device and synchronizing passwords by bringing Chrome's Autofill feature to Android. Once a user opts-in, Autofill will work out-of-the-box for most apps. Developers can optimize their apps for Autofill by providing hints about the type of data expected or add support in custom views. 
  • A new homescreen for Android TV makes it easy for users to find, preview, and watch content provided by apps. Apps can publish one or more channels, and users can control the channels that appear on the homescreen. You’ll be able to get started with creating channels using the new TvProvider support library APIs
  • Smart Text Selection: In Android O, we’re applying on-device machine learning to copy/paste, to let Android recognize entities like addresses, URLs, telephone numbers, and email addresses. This makes the copy/paste experience better by selecting the entire entity and surfacing the right apps to carry out an action based on the type of entity.
  • TensorFlow Lite: As Android continues to take advantage of machine learning to improve the user experience, we want our developer partners to be able to do the same. Today we shared an early look at TensorFlow Lite, an upcoming project based on TensorFlow, Google’s open source machine learning library. TensorFlow Lite is specifically designed to be fast and lightweight for embedded use cases. Since many on-device scenarios require real-time performance, we’re also working on a new Neural Network API that TensorFlow can take advantage of to accelerate computation. We plan to make both of these available to developers in a maintenance update to O later this year, so stay tuned!  
(L) Android O: Picture-in-picture, (R) Android O: Notification dots
Working on the Vitals in Android
We think Android’s foundations are critical, so we’re investing in Android Vitals, a project focused on optimizing battery life, startup time, graphic rendering time, and stability. Today we showcased some of the work we’ve done so far, and introduced new tools to help developers understand power, performance, and reliability issues in their apps:
  • System optimizations: in Android O, we’ve done a lot of work across the system to make apps run faster and smoother. For example we made extensive changes in our runtime - including new optimizations like concurrent compacting garbage collection, code locality, and more. 
  • Background limits: up to now it’s been fairly easy for apps to unintentionally overuse resources while they’re in the background, and this can adversely affect the performance of the system. So in O, we've introduced new limits on background location and wi-fi scans, and changes in the way apps run in the background. These boundaries prevent overuse -- they’re about increasing battery life and freeing up memory.
  • New Android Vitals Dashboards in the Play Console: today we launched six Play Console dashboards to help you pinpoint common issues in your apps - excessive crash rate, ANR rate, frozen frames, slow rendering, excessive wakeups, and stuck wake locks, including how many users are affected, with guidance on the best way to address the issues. You can visit the Play Console today to see your app's data, then learn how to address any issues.
Android Go
Part of Android’s mission is to bring computing to everyone. We’re excited about seeing more users come online for the first time as the price of entry level smart phones drop, and we want to help manufacturers continue to offer lower-cost devices that provide a great experience for these users. Today we gave a sneak peek of a new experience that we’re building specifically for Android devices that have 1GB or less of memory -- Internally we call it “Android Go,” and it’s designed around three things
  • OS: We’re optimizing Android O to run smoothly and efficiently on entry-level devices
  • Apps: We’re also designing Google apps to use less memory, storage space, and mobile data, including apps such as YouTube Go, Chrome, and Gboard. 
  • Play: On entry-level devices, Play store will promote a better user experience by highlighting apps that are specifically designed for these devices -- such as apps that use less memory, storage space, and mobile data -- while still giving users access to the entire app catalog.
The Android Go experience will ship in 2018 for all Android devices that have 1GB or less of memory. We recommend getting your apps ready for these devices soon -- take a look at the Building for Billions to learn about the importance of offering a useful offline state, reducing APK size, and minimizing battery and memory use.

O Developer Preview 2, Now in Public Beta
Today’s release of O Developer Preview 2 is our first beta-quality candidate, available to test on your primary phone or tablet. We’re inviting those who want to try the beta release of Android O to enroll now at android.com/beta -- it’s an incredibly convenient way to preview Android O on your Nexus 5X, 6P, and Player, as well as Pixel, Pixel XL, or Pixel C device.

With more users starting to get Android O on their devices through the Android Beta program, now is the time to test your apps for compatibility, resolve any issues, and publish an update as soon as possible. See the migration guide for steps and a recommended timeline.

Later today you’ll be able to download the updated tools for developing on Android O, including the latest canaries of Android Studio, SDK, and tools, Android O system images, and emulators. Along with those, you’ll be able to download support library 26.0.0 beta and other libraries from our new Maven repo. The change to Maven from SDK Manager means a slight change to your build configuration, but gives you much more flexibility in how you integrate library updates with your CI systems.

When you’re ready to get started developing with Android O, visit the O Developer Preview site for details on all of the features you can use in your apps, including notification channels and dots, picture-in-picture, autofill, and others. APIs have changed since the first developer preview, so take a look at the diff report to see where your code might be affected.

Thanks for the feedback you’ve given us so far. Please keep it coming, about Android O features, APIs, issues, or requests -- see the Feedback and Bugs page for details on where to report feedback.
Categories: Programming

Android and Architecture

Android Developers Blog - Mon, 05/22/2017 - 07:19
a { font-weight:900; } pre { font-size:14px; }

The Android operating system provides a strong foundation for building apps that run well on a wide range of devices and form factors. That being said, we've listened to developer feedback; Issues like complex lifecycles and the lack of a recommended app architecture make it challenging to write robust apps.

We need to make it easier — and more fun — to write robust apps, empowering developers to focus on areas where they can innovate. Today we're announcing a guide to Android app architecture along with a preview of Architecture Components. Rather than reinventing the wheel, we're also recognizing the work done by popular Android libraries.

Opinions not Prescriptions

We know that there's more than one way to write Android applications.  What we're providing is a set of guidelines that can help you architect an Android application to work best with the unique ways that Android interacts. The Android framework has well-defined APIs to handle contact points with the OS, such as Activities, but these are entry points into your application, not building blocks for your application architecture; Framework components don't force you to separate your data model from your UI components, or provide a clear way to persist data independent of the lifecycle.

Building Blocks

Android Architecture Components work together to implement a sane app architecture, while they individually address developer pain points. The first set of these components helps you:

  • Automatically manage your activity and fragment lifecycles to avoid memory and resource leaks
  • Persist Java data objects to an SQLite database

Lifecycle Components New lifecycle-aware components provide constructs to tie core components of your applications to lifecycle events, removing explicit dependency paths.

A typical Android observation model would be to start observation in onStart() and stop observation in onStop().  This sounds simple enough, but often times you'll have several asynchronous calls happening at once, all managing the lifecycles of their component.  It's easy to miss an edge case.  The lifecycle components can help.

Lifecycle, LifecycleOwner, and LifecycleObserver

The core class for all of this is Lifecycle. It uses an enumeration for the current lifecycle state along with an enumeration for lifecycle events to track the lifecycle status for its associated component.

Lifecycle States and Events

LifecycleOwner is an interface that returns a Lifecycle object from the getLifecycle() method, while LifecycleObserver is a class that can monitor the component's lifecycle events by adding annotations to its methods. Putting this all together, we can create lifecycle-aware components that can both monitor lifecycle events and query the current lifecycle state.

public class MyObserver implements LifecycleObserver {
  public MyObserver(Lifecycle lifecycle) {
    // Starts lifecycle observation
    lifecycle.addObserver(this);
   ...
  }
  public void startFragmentTransaction() {
     // Queries lifecycle state
     if (lifecycle.getState.isAtLeast(STARTED)) {
        // perform transaction
     }
  }
  
  // Annotated methods called when the associated lifecycle goes through these events
  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  public void onResume() {
  }
  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  public void onPause() {
  }
}
MyObserver observer = new MyObserver(aLifecycleOwner.getLifecycle());
LiveData

LiveData is an observable lifecycle-aware data holder class. Your UI code subscribes to changes in the underlying data, tied into a LifecycleOwner, and LiveData makes sure the observer:

  • Gets updates to the data while the Lifecycle is in an active state (STARTED or RESUMED)
  • Is removed when the LifecycleOwner is destroyed
  • Gets up-to-date data when the LifecycleOwner restarts due to a configuration change or is restarted from the back stack

This helps to eliminate many pathways for memory leaks, and reduces crashes by avoiding updates to stopped activities.

LiveData can be observed by many listeners, each tied to a lifecycle owner such as a Fragment or Activity.

ViewModel

ViewModel is a helper class that contains UI data for an Activity or Fragment that serves to separate view data ownership from UI controller logic. A ViewModel is retained as long as the scope of its Activity/Fragment is alive, including when the Activity/Fragmentis destroyed and recreated due to a configuration change; This allows ViewModel to make UI data available to the recreated activity or fragment instance. Wrapping UI data stored within the ViewModel with LiveData provides the data an observable lifecycle-aware home. LiveData handles the notification side of things while the ViewModel makes sure that the data is retained appropriately.

Data Persistence

The Android Architecture Components also simplify data persistence with the Room library. Room provides an object-mapping abstraction layer that allows fluent database access while harnessing the full power of SQLite.

The core framework provides built-in support for working with raw SQL content. Although these APIs are powerful, they are fairly low-level and require a great deal of time and effort to use:

  • There is no compile-time verification of raw SQL queries.
  • As your schema changes, you need to update the affected SQL queries manually. This process can be time consuming and error prone.
  • You need to write lots of boilerplate code to convert between SQL queries and Java data objects.

Room takes care of these concerns for you while providing an abstraction layer over SQLite.

Database, Entity, and DAO

There are three major components in Room:

  • Entity represents the data for a single database row, constructed using an annotated Java data object. Each Entity is persisted into its own table.
  • DAO (Data Access Object) defines the methods that access the database, using annotations to bind SQL to each method.
  • Database is a holder class that uses annotations to define the list of entities and database version. The class content defines the list of DAOs. It's also the main access point for the underlying database connection.

To use Room, you annotate the Java data objects you wish to persist as entities, create a database containing these entities, and define a DAO class with the SQL to access and modify the database.

@Entity
public class User {
    @PrimaryKey
    private int uid;
    private String name;
    // Getters and Setters - required for Room
    public int getUid() { return uid; }
    public String getName() { return name; }
    public void setUid(int uid) { this.uid = uid; }
    public void setName(String name) { this.name = name; }
}

@Dao
public interface UserDao {
    @Query("SELECT * FROM user")
    List getAll();
    @Insert
    void insertAll(User... users);
}

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}
Guide to App Architecture

Architecture Components are designed to be standalone, but they're most effective when they're incorporated into an effective app architecture. Today we're launching a Guide to App Architecture that shows how to build a robust, modular, and testable app using Architecture Components. The Guide has three main goals:

  •  Defining principles that apply to Android app development. 
  • Describing an app architecture that works with those principles. 
  • Showing how to implement that architecture using Architecture Components. 

We recommend all developers who have had to deal with these problems read the Guide; Even if you're happy with your existing app architecture, the Guide will have useful principles and insights.

Just the Beginning 

We're planning to continue being opinionated, and to continue to introduce new Architecture Components to make it easier for Android developers to make informed choices when architecting their applications. We encourage you to try the preview and provide feedback on what we're doing, because we're all in this together to make robust Android app development easier and more fun.

To learn more about Android Architecture, check out:

Categories: Programming

SPaMCAST 443 – Brad Clark, Cost Estimation COCOMO II, COCOMO III

SPaMCAST Logo

http://www.spamcast.net

Listen Now
Subscribe on iTunes
Check out the podcast on Google Play Music

The next Software Process and Measurement Cast features our interview with Brad Clark.  Brad and I talked about cost estimation, estimation in government and COCOMO II and what is on the way in COCOMO III. Even if you are firmly in the #NoEstimates camp this interview will give you ideas to think about!

Brad’s Bio

Dr. Brad Clark is Vice-President of Software Metrics Inc. – a Virginia-based consulting company. His area of expertise is in software cost and schedule data collection, analysis and modeling. He also works with clients to set up their own estimation capability for use in planning and managing. He has also helped clients with software cost and schedule feasibility analysis and cost estimation training.

Dr. Clark received his Master’s in Software Engineering in 1995 and Ph.D. in Computer Science in 1997 from the University of Southern California. He is a co-author of the most widely used Software Cost Estimation model in the world, COCOMO II. This model estimates the effort and duration required to complete a software development project.

Email: brad@software-metrics.com

Re-Read Saturday News

This week we tackle Chapter 5 of Holacracy: The New Management System for a Rapidly Changing World by Brian J. Robertson published by Henry Holt and Company in 2015.  Chapter 5, Operations, puts the roles and policies defined in governance to work.  Next week we will have some VERY exciting news about the next book in the Re-read Saturday feature!

Catch up on the first four entries in the re-read

Week 1:  Logistics and Introduction

Week 2: Evolving Organization

Week 3: Distribution Authority

Week 4: Organizational Structure

Week 5: Governance

Week 6: Operations (Current Week)

Visit the Software Process and Measurement Cast blog to participate in this and previous re-reads.

 

A Call To Action

If you got a new idea this week while listening to the podcast, please give the SPaMCAST a short, honest review in iTunes.  Reviews help guide people to the cast!

Next SPaMCAST

The next Software Process and Measurement Cast will our essay re-visiting the product owner role.  The product owner role is hard, often messed up and a great opportunity for improvement.

We will also have columns from Steve Tendon and Jeremy Berriault. This will be an important cast to start the summer season in the northern hemisphere!

Shameless Ad for my book!

Mastering Software Project Management: Best Practices, Tools and Techniques co-authored by Murali Chematuri and myself and published by J. Ross Publishing. We have received unsolicited reviews like the following: “This book will prove that software projects should not be a tedious process, for you or your team.” Support SPaMCAST by buying the book here. Available in English and Chinese.


Categories: Process Management

SPaMCAST 443 - Brad Clark, Cost Estimation COCOMO II, COCOMO III

Software Process and Measurement Cast - Sun, 05/21/2017 - 22:00

The next Software Process and Measurement Cast features our interview with Brad Clark.  Brad and I talked about cost estimation, estimation in government and COCOMO II and what is on the way in COCOMO III. Even if you are firmly in the #NoEstimates camp this interview will give you ideas to think about!

Brad’s Bio

Dr. Brad Clark is Vice-President of Software Metrics Inc. – a Virginia-based consulting company. His area of expertise is in software cost and schedule data collection, analysis and modeling. He also works with clients to set up their own estimation capability for use in planning and managing. He has also helped clients with software cost and schedule feasibility analysis and cost estimation training.

Dr. Clark received his Master’s in Software Engineering in 1995 and Ph.D. in Computer Science in 1997 from the University of Southern California. He is a co-author of the most widely used Software Cost Estimation model in the world, COCOMO II. This model estimates the effort and duration required to complete a software development project.

Email: brad@software-metrics.com

Re-Read Saturday News

This week we tackle Chapter 5 of Holacracy: The New Management System for a Rapidly Changing World by Brian J. Robertson published by Henry Holt and Company in 2015.  Chapter 5, Operations, puts the roles and policies defined in governance to work.  Next week we will have some VERY exciting news about the next book in the Re-read Saturday feature!

Catch up on the first four entries in the re-read

Week 1:  Logistics and Introduction

Week 2: Evolving Organization

Week 3: Distribution Authority

Week 4: Organizational Structure

Week 5: Governance

Week 6: Operations (Current Week)

Visit the Software Process and Measurement Cast blog to participate in this and previous re-reads.

 

A Call To Action

If you got a new idea this week while listening to the podcast, please give the SPaMCAST a short, honest review in iTunes.  Reviews help guide people to the cast!

Next SPaMCAST

The next Software Process and Measurement Cast will our essay re-visiting the product owner role.  The product owner role is hard, often messed up and a great opportunity for improvement.

We will also have columns from Steve Tendon and Jeremy Berriault. This will be an important cast to start the summer season in the northern hemisphere!

Shameless Ad for my book!

Mastering Software Project Management: Best Practices, Tools and Techniques co-authored by Murali Chematuri and myself and published by J. Ross Publishing. We have received unsolicited reviews like the following: “This book will prove that software projects should not be a tedious process, for you or your team.” Support SPaMCAST by buying the book here. Available in English and Chinese.

Categories: Process Management

Quote of the Day

Herding Cats - Glen Alleman - Sun, 05/21/2017 - 14:08

“There is nothing which rots morale more quickly and more completely than … the feeling that those in authority do not know their own minds.” — “Span of Control," Lionel Urwick, Harvard Business Review, May/June 1956

Categories: Project Management

Holacracy: Re-read Week 6, Chapter 5 – Operations

Book Cover

Holacracy

This week we tackle Chapter 5 of Holacracy: The New Management System for a Rapidly Changing World by Brian J. Robertson published by Henry Holt and Company in 2015.  Chapter 5, Operations, puts the roles and policies defined in governance to work.

Robertson starts Chapter 5 by recalling the adage – slow down to speed up. We are being exhorted to pull back from the day-to-day work in order to improve how the organization is organized by listening to a diverse group of people.  The use the structure of the organization defined as part of governance to do work is operations. Said differently, everything that does not fall into the responsibility of governance is operations. Operations are about using the structure to find a governance.

The Basics of Operations

Critical Definitions:  In Holacracy, Robertson uses two definitions from the book Getting Things Done (David Allen).  The first is that a project is an outcome to be achieved and second that a next step is a concrete physical action that could be executed now. 

Operations are focused on doing tasks or projects.  Robertson describes a basic behavior pattern for each project or pieces of work.  Begin by defining a clear set of criteria that must be true for the project to compete.  The criteria should be as clear as a true or false question.  Then take the first step. When the step is a complete test whether the project completion criteria has been satisfied.  You are either done or you take the next step.  Those that are familiar with test first development will recognize and be heartened by the pattern.

One of the central values of Holacracy is that people throughout an organization must have clear autonomy to take decisive action. That authority comes with increased accountability to self-manage. Self-management requires the explicit responsibilities of sensing and processing tensions (Robertson’s words for the stress between roles and processes), executing accountabilities, working through and tracking projects, taking next actions, directing attention, people and resources. Except in the very simplest role, every individual needs a system to help them fulfill their responsibilities.  The complexity of roles in an organization makes it impossible to keep everything in your head.

Every circle member has a set of basic duties:

  1.   The duty of transparency.  This duty has four sub-duties; sharing projects and next actions, making sure the order of work (relative priority) is known, making and sharing projections of when work is likely to be done, and providing a checklist of and the metrics needed for tactical meetings (discussed later).
  2.   The duty of processing accountabilities. This duty is subdivided into three sub-duties. For projects and tasks that are part of your role, you have the duty to process it to a next clear action. If you are presented with requests for actions you have the duty to consider the request to take on the task if it fits into one of your accountabilities. And, if a request is made to impact the domain you control you have the duty to consider the request and may accept or decline.
  3.   The duty of prioritization.  This duty can also be sub-decided; you have the duty to prioritize or ad-hoc execution, a request for a tactical or governance meeting takes priority over execution except when there is a delivery constraint (remember that tactical and governance meeting get blockages out of the way), and  it is the duty of the individual to prioritize the circle needs and goals over the goals and needs of the individual’s goals.  Individual goal should be aligned with the circle’s goals

Tactical Meetings

The tool that makes operations work in Holacracy are the tactical meetings. Tactical meetings are for getting help when you don’t know what to do next, enable the circle to discuss operational issues, get updates on projects, find out what other roles are working on, give updates on your project and to ask for help when needed. Tactical meetings vary in frequency, but is often are weekly.  The magic is not in just having a meeting, but rather in the structure and process.

The flow of tactical meetings follows seven steps.

  1.      Check-In Round – This round follows the same process defined for the Governance Meeting.  The round is about getting present and no crosstalk is allowed.
  2.      Checklist Review – List the recurring actions by discipline.  The review is a simple recitation of yes (if done) or no (if not done).  Checklist items are typically defined by the role; however, any other role can add items to the role if the role needs to know that an action has been taken on a recurring basis. Note—this is a brilliantly simple approach to making sure a role stays focused.  The facilitator reads the list and the role responds.  Simple explanations are allowed but NO open discussion.
  3.      Metrics Review – Metrics, either defined by the role or by the lead link, are reported.  Questions are allowed to make sure the data is understood but NO open discussion or other suggestions.
  4.      Progress Updates – This role is focused on changes since the last tactical meeting ONLY. If no progress has been made since the last meeting then the update should be simply “no update.”
  5.      Agenda Building – As with the governance meeting, agenda for the issues is built during the meeting.  Each member of the circle can raise the issue and put them on the agenda.
  6.      Triage Issues – Agenda items are processed one at a time by giving the owner of the item the time to engage others in the circle until the item is addressed or a next step is identified and accepted. The facilitator listens for the breakpoint and then moves to the next item. The secretary captures resolution or next steps.  When an item change leads to a need to change a role or policy, the item is routed to a governance meeting.
  7.      Closing Round – Each person reflects on the meeting one at a time without discussion.  Depending on the size of the circle I suggest ensuring that the agenda includes 5 – 10 minutes to address this step.

One of the important considerations woven throughout Holacracy is the need for transparency and follow through.  When an individual accepts a next step that acceptance represents a form of commitment. The commitment is to consciously track the issue, to consciously review the next step, and to consciously take the action as soon as it becomes the most important item among your possible actions on your backlog.  This feels very much like backlog grooming and management.

Remember to buy a copy of Holacracy (use the link in the show notes to help support and defray the costs of the Software Process and Measurement Cast blog and podcast).

Previous Entries in the re-read:

Week 1:  Logistics and Introduction

Week 2: Evolving Organization

Week 3: Distribution Authority

Week 4: Organization Structure

Week 5: Governance

 


Categories: Process Management

Holacracy: Re-read Week 6, Chapter 5 – Operations

Book Cover

Holacracy

This week we tackle Chapter 5 of Holacracy: The New Management System for a Rapidly Changing World by Brian J. Robertson published by Henry Holt and Company in 2015.  Chapter 5, Operations, puts the roles and policies defined in governance to work.

Robertson starts Chapter 5 by recalling the adage – slow down to speed up. We are being exhorted to pull back from the day-to-day work in order to improve how the organization is organized by listening to a diverse group of people.  The use the structure of the organization defined as part of governance to do work is operations. Said differently, everything that does not fall into the responsibility of governance is operations. Operations are about using the structure to find a governance.

The Basics of Operations

Critical Definitions:  In Holacracy, Robertson uses two definitions from the book Getting Things Done (David Allen).  The first is that a project is an outcome to be achieved and second that a next step is a concrete physical action that could be executed now. 

Operations are focused on doing tasks or projects.  Robertson describes a basic behavior pattern for each project or pieces of work.  Begin by defining a clear set of criteria that must be true for the project to compete.  The criteria should be as clear as a true or false question.  Then take the first step. When the step is a complete test whether the project completion criteria has been satisfied.  You are either done or you take the next step.  Those that are familiar with test first development will recognize and be heartened by the pattern.

One of the central values of Holacracy is that people throughout an organization must have clear autonomy to take decisive action. That authority comes with increased accountability to self-manage. Self-management requires the explicit responsibilities of sensing and processing tensions (Robertson’s words for the stress between roles and processes), executing accountabilities, working through and tracking projects, taking next actions, directing attention, people and resources. Except in the very simplest role, every individual needs a system to help them fulfill their responsibilities.  The complexity of roles in an organization makes it impossible to keep everything in your head.

Every circle member has a set of basic duties:

  1.   The duty of transparency.  This duty has four sub-duties; sharing projects and next actions, making sure the order of work (relative priority) is known, making and sharing projections of when work is likely to be done, and providing a checklist of and the metrics needed for tactical meetings (discussed later).
  2.   The duty of processing accountabilities. This duty is subdivided into three sub-duties. For projects and tasks that are part of your role, you have the duty to process it to a next clear action. If you are presented with requests for actions you have the duty to consider the request to take on the task if it fits into one of your accountabilities. And, if a request is made to impact the domain you control you have the duty to consider the request and may accept or decline.
  3.   The duty of prioritization.  This duty can also be sub-decided; you have the duty to prioritize or ad-hoc execution, a request for a tactical or governance meeting takes priority over execution except when there is a delivery constraint (remember that tactical and governance meeting get blockages out of the way), and  it is the duty of the individual to prioritize the circle needs and goals over the goals and needs of the individual’s goals.  Individual goal should be aligned with the circle’s goals

Tactical Meetings

The tool that makes operations work in Holacracy are the tactical meetings. Tactical meetings are for getting help when you don’t know what to do next, enable the circle to discuss operational issues, get updates on projects, find out what other roles are working on, give updates on your project and to ask for help when needed. Tactical meetings vary in frequency, but is often are weekly.  The magic is not in just having a meeting, but rather in the structure and process.

The flow of tactical meetings follows seven steps.

  1.      Check-In Round – This round follows the same process defined for the Governance Meeting.  The round is about getting present and no crosstalk is allowed.
  2.      Checklist Review – List the recurring actions by discipline.  The review is a simple recitation of yes (if done) or no (if not done).  Checklist items are typically defined by the role; however, any other role can add items to the role if the role needs to know that an action has been taken on a recurring basis. Note—this is a brilliantly simple approach to making sure a role stays focused.  The facilitator reads the list and the role responds.  Simple explanations are allowed but NO open discussion.
  3.      Metrics Review – Metrics, either defined by the role or by the lead link, are reported.  Questions are allowed to make sure the data is understood but NO open discussion or other suggestions.
  4.      Progress Updates – This role is focused on changes since the last tactical meeting ONLY. If no progress has been made since the last meeting then the update should be simply “no update.”
  5.      Agenda Building – As with the governance meeting, agenda for the issues is built during the meeting.  Each member of the circle can raise the issue and put them on the agenda.
  6.      Triage Issues – Agenda items are processed one at a time by giving the owner of the item the time to engage others in the circle until the item is addressed or a next step is identified and accepted. The facilitator listens for the breakpoint and then moves to the next item. The secretary captures resolution or next steps.  When an item change leads to a need to change a role or policy, the item is routed to a governance meeting.
  7.      Closing Round – Each person reflects on the meeting one at a time without discussion.  Depending on the size of the circle I suggest ensuring that the agenda includes 5 – 10 minutes to address this step.

One of the important considerations woven throughout Holacracy is the need for transparency and follow through.  When an individual accepts a next step that acceptance represents a form of commitment. The commitment is to consciously track the issue, to consciously review the next step, and to consciously take the action as soon as it becomes the most important item among your possible actions on your backlog.  This feels very much like backlog grooming and management.

Remember to buy a copy of Holacracy (use the link in the show notes to help support and defray the costs of the Software Process and Measurement Cast blog and podcast).

Previous Entries in the re-read:

Week 1:  Logistics and Introduction

Week 2: Evolving Organization

Week 3: Distribution Authority

Week 4: Organization Structure

Week 5: Governance

 


Categories: Process Management

MOE's and MOP's for a Capability

Herding Cats - Glen Alleman - Sat, 05/20/2017 - 23:18

If we are to make logical decisions and choices in product and systems development, we need to have criteria to measure the value or relative importance of aspects of alternative proposals. This is an essential pre‒requisite for part of trade studies. Both the client (customer, user) and the engineer have such measures, and these are related.

  • Measures of Effectiveness (MoE) represent the customer view, usually annotated and of qualitative nature. They describe the customers’ expectations of a product, project or system; the voice of the customer.
  • Measures of Performance (MoP) are the corresponding view of the engineer; a technical specification for a product. Typically Measures for Performance are quantitative and consist of a range of values about the desired point. These values are what an engineer targets when designing the product, by changing shape, materials and manufacturing process, so as to finally achieve the qualities desired by the customer.

Many of the results from this method may appear to be logical and obvious requirements. However, as the product becomes more complex, the systematic approach of breaking down the customers’ requirements into their most basic components, aids to understanding where requirements were derived.

This method enables the formation of a complete list of customer needs and wants, from which broad engineering specifications are developed. When developing the Measures of Performance, it is necessary to distinguish needs and wants in the design. These then enable engineering design to proceed with some basic known constraints and variables. Weightings can be attached to each design requirement, both for Measures of Effectiveness and Measures of Performance. Evaluation of alternate designs can be made through the use of a method such as “Weighted objective decision matrix” or similar methods.

MOE MOP

[1] The University of Queensland, MECH4551 – System Design Projects – Semester 2 2001, Design Methods Fact Sheet Measures of Effectiveness (MOE) and Measures of Performance (MOP)

Related articles Estimating Processes in Support of Economic Analysis The Art of Systems Architecting Capabilities Based Planning A Framework for Managing Other Peoples Money Architecture -Center ERP Systems in the Manufacturing Domain IT Risk Management Why Guessing is not Estimating and Estimating is not Guessing Making Conjectures Without Testable Outcomes
Categories: Project Management

MOE's and MOP's for a Capability

Herding Cats - Glen Alleman - Sat, 05/20/2017 - 23:18

If we are to make logical decisions and choices in product and systems development, we need to have criteria to measure the value or relative importance of aspects of alternative proposals. This is an essential pre‒requisite for part of trade studies. Both the client (customer, user) and the engineer have such measures, and these are related.

  • Measures of Effectiveness (MoE) represent the customer view, usually annotated and of qualitative nature. They describe the customers’ expectations of a product, project or system; the voice of the customer.
  • Measures of Performance (MoP) are the corresponding view of the engineer; a technical specification for a product. Typically Measures for Performance are quantitative and consist of a range of values about the desired point. These values are what an engineer targets when designing the product, by changing shape, materials and manufacturing process, so as to finally achieve the qualities desired by the customer.

Many of the results from this method may appear to be logical and obvious requirements. However, as the product becomes more complex, the systematic approach of breaking down the customers’ requirements into their most basic components, aids to understanding where requirements were derived.

This method enables the formation of a complete list of customer needs and wants, from which broad engineering specifications are developed. When developing the Measures of Performance, it is necessary to distinguish needs and wants in the design. These then enable engineering design to proceed with some basic known constraints and variables. Weightings can be attached to each design requirement, both for Measures of Effectiveness and Measures of Performance. Evaluation of alternate designs can be made through the use of a method such as “Weighted objective decision matrix” or similar methods.

MOE MOP

[1] The University of Queensland, MECH4551 – System Design Projects – Semester 2 2001, Design Methods Fact Sheet Measures of Effectiveness (MOE) and Measures of Performance (MOP)

Related articles Estimating Processes in Support of Economic Analysis The Art of Systems Architecting Capabilities Based Planning A Framework for Managing Other Peoples Money Architecture -Center ERP Systems in the Manufacturing Domain IT Risk Management Why Guessing is not Estimating and Estimating is not Guessing Making Conjectures Without Testable Outcomes
Categories: Project Management

Google I/O: New Ways to Put Users at the Center of Your Apps and Payments

Google Code Blog - Fri, 05/19/2017 - 18:55
Cross posted from Inside AdMob

Posted by Sridhar Ramaswamy, Senior Vice President, Ads and Commerce

I/O is a magical time at Google. Every year, thousands of developers gather in Google's backyard to share new product ideas and learn about our latest innovations in computing.

We're meeting at an exciting time for the developer community. It's a time when consumers have more choices than ever before—like where to shop, what to watch, which games to play and how to communicate with friends and family. Your product needs to stand out. You need tools to help your business grow. And you need to make sure your users are happy.

We think we can help.

This week, my team and I shared 3 new innovations for developers to make it easy for users to pay for your services, build profitable businesses and grow your user base.
Enabling users to pay with Google

Starting today, our suite of payment solutions will be expanding. The Google Payment API enables merchants and developers to turbocharge checkout conversion by offering your users an easy way to pay with credit and debit cards saved to their Google Account. Users will have multiple Google payment options at their fingertips, like a credit or a debit card previously saved via Android Pay, a payment card used to transact on the Play Store or a form of payment stored via Chrome. And they'll be able to use these saved payment options in third-party apps and mobile sites, as well as on Google Assistant when they are on-the-go.

Paying with Google for Panera Bread on Google Assistant
For users, this means faster checkout. Now they'll never miss a deal because they're stuck on a bus and don't want to pull out their credit card in front of strangers. They'll no longer experience the pain of stumbling on a sale that ends at midnight when they're tucked in bed with their credit card out of reach. Users can save time and headache by using credit and debit cards they've already saved to their Google Account whenever they see the option to pay with Google on supported apps or sites.

For developers, this API is a significant innovation that can enable faster checkout, drive more conversions, increase sales and reduce abandoned carts—all with a simple integration. Learn more about our Google Payment API here.
Earn more from your apps with the brand new AdMob
People turn to their mobile devices throughout the day to shop, communicate and stay entertained. For developers, in-app purchases are one way to monetize. Ads are another way.
AdMob was built to support the app ecosystem. With over 1 million apps across iOS and Android, AdMob has paid over $3.5 billion dollars in ads revenue to developers. But there's more we can do to help you succeed.

Today, we're introducing a completely redesigned AdMob. Rebuilt from the ground up, AdMob is now simpler to use and delivers richer insights about your users' in-app experiences.

Simpler to use: We've applied Material Design to all aspects of the AdMob look and feel to deliver an easy-to-use and intuitive experience across the entire platform—on mobile and desktop. You'll get more done in less time. Below you can see how easy it is to pick an app that you're monitoring, check out its key metrics and then quickly take action to fine-tune its performance.

Redesigned AdMob experience Deeper insights: We've also integrated Google Analytics for Firebase into the core of the redesigned AdMob so you have quick access to the metrics that matter most for your business. Once you link your AdMob and Firebase accounts, you'll have access to detailed ad revenue data and user insights like time spent in the app and in-app purchases—all in one place.
Google Analytics for Firebase dashboard in AdMob
Know your user, find your user with Universal App Campaigns
Earning money from your app is one piece of the puzzle. You also need to think about how to grow your user base.

Google's app innovations have delivered over 5 billion installs from ads and we are now helping developers drive over 3 billion in-app events per quarter—like users adding something to their cart or reaching level 3 of a game. Developers have gravitated toward Universal App Campaigns (UAC) as the "one stop shop" campaign type that scales your reach and maximizes app installs across Google's largest properties: Google Play, Search, YouTube, Gmail and the Display Network. UAC uses Google's machine learning technology to evaluate numerous signals in real time, refining each ad to help you reach your most engaged users. We're continuing to double down on UAC, with all new innovations being built into UAC to make app promotion even more effective.
Engage users in key moments of discovery with new UAC placements in Google Play Android reaches more than 2 billion active devices every month, with Google Play available in 190+ countries around the world. It's the place users come to discover new apps and games. Beyond searching for apps to try, users are increasingly browsing the Play store and finding recommendations for new apps. To help those users discover more of your apps, we are introducing new ad placements on the home and app listing pages in the Google Play Store. These new placements, available exclusively through UAC, help you reach users in "discovery mode" as they swipe, tap and scroll in search of their next favorite app. 
New ad placements reach users browsing in Google Play Discover more of your best users with new bidding options in UAC Some users are more valuable to your business than others, like the players who level-up in your game or the loyal travelers who book several flights a month. That's why we're expanding Smart Bidding strategies in UAC to help you acquire more of these high-value users. Using Smart Bidding, you can tailor bids for your unique business goals - target cost per acquisition (tCPA) or target return on ad spend (tROAS). UAC delivers the right users based on your objectives: installs, events and, coming soon, value. This update starts rolling out to iOS and Android developers and advertisers in the coming months. Introducing App Attribution Partners, a new measurement program Many developers rely on third-party measurement providers to measure the impact of ads and gain valuable insights about how users engage with your app. To help you take action on these insights in a faster and more seamless way, we are introducing App Attribution Partners, a new program designed to integrate data from 7 global companies right into AdWords.

Welcome to adjust, Adways, AppsFlyer, Apsalar, CyberZ, Kochava and TUNE... we're thrilled to have them onboard!

AdWords' integration with these partners ensures that you have consistent, reliable and more granular data where you review app metrics. Now you can take action with confidence and stay on top of your business performance.
As consumers live more of their lives online, it's increasingly important for developers to build user-centric experiences in everything that you do—from the apps you design, to the experiences you deliver, to the ways you help people transact. We know it's not always easy, so Google is here to help.

We look forward to continuing on this journey with you.
Categories: Programming

There is Little New Under the Sun

Herding Cats - Glen Alleman - Fri, 05/19/2017 - 18:47

It is popular to claim we've never done this before, so how can we possibly estimate the cost and schedule. If it truly hasn't been done before, then the software project is likely to be an inventing new physics project. Having worked in the particle physics domain, inventing new physics is something I'm familiar with. In that world, we still made estimates of the cost to design, build, and operate the experiment. As well we made estimates of what information will be produced after spending the customers (in most cases the government is the customer) money. Estimates are made of the data quality, the aleatory and epistemic uncertainties of the experimental processes and the data they produce. 

Estimates are at the heart of all inventing new physics activities.

So no more cockamamy examples of we can't possibly know. Instead, invert that logic. If it's knowable, then go find someone who does and admit, that person may not be you. 

One place to start is the Reference Class database of projects. Here's a small sample from Capers Jones and ICEAA materials.

So when you hear we can't know how long - what it really means is -  I personally or my colleagues don't know how to estimate. But since ...

There is NO principle by which you can decide in the presence of uncertainty without estimating. 

For those asking and paying, there are several choices.

  • Ask the development team to research the problem in one of several ways - find a reference classbuild a model from a prototype, or similar exploration processes before increasing the fidelity of the estimate.
  • Go find someone who knows how to do this and hire them.

This way, as the person paying for the Value produced by the work, you can start down the path of holding the development team accountable for their work. And that development team can start holding you accountable for being a good manager.

Some Background on this Topic

[1] Physical Percent Complete

[2] Avoid Software Project Horror Stories

[3] Applying Deliverables Based Planning

[4] Principles of Program Governance

Related articles The Fallacy of the Planning Fallacy IT Risk Management Why Guessing is not Estimating and Estimating is not Guessing Making Conjectures Without Testable Outcomes Deadlines Always Matter
Categories: Project Management

Make more money with subscriptions on Google Play

Android Developers Blog - Fri, 05/19/2017 - 18:30
Posted by George Audi, Tom Grinsted and Larry Yang, Google Play

The subscription business model is one of the best ways to make more regular, reliable, and recurring revenue on Android and Google Play. In fact, both developers and users love subscription apps so much that we’ve seen a 10X growth in consumer spend over the past three years and double the number of active subscribers in the past year. Thousands of developers are offering subscriptions through Google Play and are already seeing success with our billing platform. That’s why we’ve been working hard to help you take advantage of this opportunity and give you greater insights into your business and Android users.

New features to help your subscriptions business thrive

You've got a high-performing product with fantastic features and compelling content, but your business can't succeed without acquiring new users. In addition to free trials, intro pricing, flexible billing periods, and more, we recently launched the ability to pay for subscriptions with Google Play balance. Although people have already been using gift cards to pay for Play content in over 20 countries, the use of gift cards to pay for subscriptions in regions where cash is a popular form of payment, such as Latin America, has resulted in as high as a 15% increase in subscription spend.

But it's not just about acquiring new customers, it's about retaining the ones you have. That's why we are introducing account hold, where we work with you to block access to your content or service if a user's form of payment fails. This directly links a payment failure to the user losing access to your content and/or premium features, which is enough to get them to go and choose a new form of payment. When Keepsafe–the developer of Keepsafe Photo Vault, a photo locker for private pictures and videos with over 50M downloads–integrated account hold, their renewal rate on Android increased by 25%. We have over a dozen developers in early access today, and we will be announcing public availability at the end of June.

We know data is vital to running your business, so we're excited to announce a new subscriptions dashboard in the Play Console, and a new report on Android app subscribers.

The dashboard brings together subscription data like new subscribers, cancellations, and total subscribers. It also displays daily and 30-day rolling revenue data, and highlights your top-performing products. This will give visibility into your subscription products and users and will help guide your business decisions.

Insights to help you grow your subscriptions business

In addition to products and features, understanding people's needs is core to building a successful subscription business. We talked to 2,000 Android app subscribers in the US and UK and asked them how and why they use the apps they do. The results shared in 'Subscription apps on Google Play: User insights to help developers win' report highlight some of the opportunities for you to grow your subscriptions user base, set pricing strategies and learn to keep your users engaged, including:

  • Use free trials to acquire users. 78% of users start with a free version of an app, and many cite a discount or end of a free trial as a reason to pay.
  • Keep your content appealing and updated to get and keep users paying. It's the most important driver in converting users from free to paid users, as well as keeping users engaged and retained.
  • There is a huge opportunity to make money from subscriptions. While pricing elasticity varies by category, few users cite price as a reason to churn from a paid subscription and 64% either budget on a per app basis or not at all (as opposed to budgeting across all app subscriptions).
To find out more about your growing your subscription business with Google Play, watch our I/O session, download the research report (PDF), and get started with subscriptions with Google Play In-app Billing.

How useful did you find this blogpost?
.stars { color: gold; text-align: center; } ★ ★ ★ ★ ★
Categories: Programming

Stuff The Internet Says On Scalability For May 19th, 2017

Hey, it's HighScalability time:

 

 

Who wouldn't want to tour the Garden of Mathematical Sciences with Plato as their guide?
If you like this sort of Stuff then please support me on Patreon.
  • 2 billion: Android users; 1,000: cloud TPUs freely available to researchers; 11.5 petaflops: in Google's machine learning pod; 86 billion: neurons in the human brain, not 100 billion; 1,300: Amazon's new warehouses across Europe; $1 trillion: China self-investment; 1/7th: California's portion of US GDP; more: repetition in songs; 99.999%: Spanner availability, strong consistency, good latency; 6: successful SpaceX launch in 4 months; 160TB: RAM in HPE computer; 40,000+ workers: private offices > open offices

  • Quotable Quotes:
    • Tim Bray: with­out ex­cep­tion, I ob­served that they [Per­son­al com­put­er­s, Unix, C, the In­ter­net and We­b, Java, REST, mo­bile, pub­lic cloud] were ini­tial­ly load­ed in the back door by geek­s, with­out ask­ing per­mis­sion, be­cause they got shit done and helped peo­ple with their job­s. That’s not hap­pen­ing with blockchain. Not in the slight­est. Which is why I don’t be­lieve in it.
    • @swardley: Amazon continues to take industry after industry not because those companies lack engineering talent but executive talent.
    • @RichRogersIoT: "I bought my boss two copies of The Mythical Man Month so that he could read it twice as fast." - @rkoutnik
    • @GossiTheDog: Seeing ATMs and banks go down here suggests fundamental issues which flashing boxes can't fix. Design, architect a security model.
    • @stevesi: Is Google's TPU investment the biggest advantage ever or laying groundwork for being disrupted? Can Google out-innovate sum of industry?
    • Ryan Mac: Last year, Craigslist took in upwards of $690 million in revenue, most of which is net profit
    • @dberkholz: Capex vs opex budget for tools is a bigger deal than I'd fully appreciated. Welcome to the enterprise!
    • Vint Cerf: AI stands for artificial idiot. 
    • Douglas Hofstadter: In the end, we are self-perceiving, self-inventing, locked-in mirages that are little miracles of self-reference. 
    • cocktailpeanuts: I feel like the term "Serverless" has been hijacked to a point that it will soon become meaningless just like "AI", "IoT", etc. Basically "Serverless" in 2017 has become just a hype friendly marketing friendly way of saying "Saas".
    • @skupor: Over last 20 years, m&a exits for venture backed companies has gone from 60% to 90% of exits (was 20% in 1990)
    • bpicolo: C# with visual studio is, I think, the most productive environment I've come across in programming. It's ergonomically sound, straightforward, and the IDE protects me from all sorts of relevant errors. Steve mentioned Intellij is a bit slower than he'd hope typing sometimes. I totally agree with that. I think Visual Studio doesn't quite suffer from that.
    • @codepitbull: A good developer is like a werewolf: Afraid of silver bullets.
    • @sehnaoui: Coffee shop. People next to me are loud and rude. They just found the perfect name for their new business. I just bought the domain name.
    • David Robinson: Python and Javascript developers start and end the day a little later than C# users, and are a little less likely than C programmers to work in the evening.
    • Ben Thompson: The fatal flaw of software, beyond the various technical and strategic considerations I outlined above, is that for the first several decades of the industry software was sold for an up-front price, whether that be for a package or a license. The truth is that software — and thus security — is never finished; it makes no sense, then, that payment is a one-time event.
    • boulos: Spanner does things for you that MySQL et al. don't. Having an automagic Regional (and eventually Global if you'd like) database without dealing with sharding is worth $8k/year even to me. So even if it could fit on $10/month of hardware, I don't begrudge them for charging a service fee, rather than saying "This is how much cores, RAM, disk and flash this eats".
    • codedokode: One of the reasons why such attack was possible is poor security in Windows. Port 445 that was used in an attack is opened by a kernel driver (at least that is what netstat says on WinXP) that runs in ring 0. This driver is enabled by default even if the user doesn't need SMB server and it cannot be easily disabled.
    • @RichRogersIoT: Job interview:  Implement Large Hadron Collider on whiteboard / Actual job:  Jira bug-id #2342: Move login button 3 pixels to left
    • slackingoff2017: This is part of a worrying new trend. Increasingly you can't buy software anymore, only rent. Innovation is being kept from scrutiny hidden behind closed doors. The kind of thing patents were meant to prevent back when the system wasn't broken.
    • Scott Borg~ Engineers need to look at their products from the standpoint of the attacker, and consider how attacker would benefit from cyberattack and how to make undertaking that attack more expensive. It’s all about working to increase an attacker’s costs
    • @tottinge: "A code base isn't a thing we build, it's a place we live. We don't seek to finish it and move on, but to make it liveable"  @sarahmei
    • Sam Kroonenburg: We Believe …Don’t do the things that someone else can do. Do the things that only we can do. [re: Serverless]
    • Anush Mohandass: What you’re starting to see are different architectures for different workloads. There will be chips for image recognition, SQL, machine learning acceleration. 
    • Craig McLuckie: Given the current state-of-the-art, most users will achieve best day-to-day top line availability by just picking a single public cloud provider and running their app on one infrastructure.
    • watmough: Chromebooks work, and I am a big fan of them in education. I have a pretty good idea how hard our teachers work, and I'd hate to think of the Windows bullshit being imposed them, like it's imposed on me and my coworkers.
    • axilmar: It [React Native] is the future! But you need experience to make it work, and navigation/routing is still being worked out, and it is native, but it is Javascript, and it is crossplatform, but you need to be aware of the differences of the two platforms, and styling uses something that is like css but not entirely, you have to learn all the intricate details... Thank god software engineering "practices" are not used in other engineering disciplines...
    • Anton Howes: So without the British acceleration of innovation, the Industrial Revolution would likely have happened elsewhere within a few decades. France and the Low Countries and Switzerland and the United States were by the eighteenth century well on their way towards sustained modern economic growth. 
    • Dr. Suzana Herculano-Houzel~ evolution is not progress, all that evolution means is change over geological time, it's not for the better, it's not for the worst, it's just different. All it has to do with is generating diversity. We have ample evidence we are not descendents of reptiles, we are close cousins. We could not have a basic reptile brain to which something else was added. We know now that every reptile has a neo-cortex. There is not such thing as triune brain. There is no such thing as reptilian brain on top of which a new structure appeared only in mammals. We all have it. The brain is very much the same in its essence, the difference lies in the quantities. 
    • James Clear: The great mistake of Hurricane Katrina was that the levees and flood walls were not built with a proper “margin of safety.” The engineers miscalculated the strength of the soil the walls were built upon. As a result, the walls buckled and the surging waters poured over the top, eroding the soft soil and magnifying the problem. Within a few minutes, the entire system collapsed.
    • elvinyung: This "modern" Spanner feels very different from the one we saw in 2012 [1]. Some interesting takeaways: * There is a native SQL interface in Spanner, rather than relying on a separate upper-layer SQL layer, a la F1 [2] * Spanner is no longer on top of Bigtable! Instead, the storage engine seems to be a heavily modified Bigtable with a column-oriented file format * Data is resharded frequently and concurrently with other operations -- the shard layout is abstracted away from the query plan using the "distributed union" operator * Possible explanation for why Spanner doesn't support SQL DML writes: writes are required to be the last step of a transaction, and there is currently no support for reading uncommitted writes (this is in contrast to F1, which does support DML) * Spanner supports full-text search (!)

  • Cautionary tale number 1000 on depending on someone else's service. Firebase Costs Increased by 7,000%! Google changed something (billing for SSL overhead) and HomeAutomation's bill spiked. There was no warning. There were no tools to tell why. Support stopped replying. There's no one to call. The recommendation is to protect yourself from being trapped by a service from the very beginning. They've moved to Lambda/DynamoDb, which many point out is also a potential service trap. The Firebase Founder responded with an explanation, saying he was "embarrassed by the level of communication on our side." Good discussion on HackerNews and on reddit. Lots of people with similar stories, complaints about lack of support with Google, complaints about lack of transparency, and the usual about never rely on anything ever. 

  • Serverlessconf Austin '17 videos are now available (most of them anyway). 

Don't miss all that the Internet has to say on Scalability, click below and become eventually consistent with all scalability knowledge (which means this post has many more items to read so please keep on reading)...

Categories: Architecture

Refactoring to Microservices – Using a Document as State

Xebia Blog - Fri, 05/19/2017 - 14:12

In a previous installment of our Microservice refactoring effort, I’ve introduced a ShopManager and a Clerk to implement the shopping process (see this blog). I ended up with a JSON document transferred between services. To make life easy for myself I just parsed all of the document using Spring magic. This time I will discuss […]

The post Refactoring to Microservices – Using a Document as State appeared first on Xebia Blog.

I/O 2017: Everything new in the Google Play Console

Android Developers Blog - Fri, 05/19/2017 - 11:48
.sup-label { color: #6ab344; font-size: 11px; line-height: 1em; margin-left: 4px; } .adb-star-ratings { color: #f1c232; font-family: Arial; font-size: 24px; vertical-align: baseline; white-space: pre-wrap; } /* helper classes */ .post-content img.mt-0 { margin-top: 0; } .adb-responsive-img { max-width: 100%; } .adb-show-on-mobile { display: none; } /* override styles */ .post-content > div.adb-center { text-align: center!important; } .adb-read-this-in { font-size: 14px; margin-bottom: 20px; } .mt-47 img { padding-top: 47px; } /* mobile styles */ .post-content img.adb-desktop-right { clear: right; float: right; margin-bottom: 1em; margin-left: 1em; } @media (max-width: 600px) { .post-content img.adb-desktop-right { clear: both; float: none; margin-left: 0; } .post-content img.adb-desktop-right { max-width: 100%; width: 100%!important; /* override inline-style */ } .adb-hide-on-mobile { display: none; } .adb-show-on-mobile { display: block; } .post-content > div.adb-center-on-mobile { text-align: center!important; } .post-content img.adb-desktop-right.adb-sml-img-mobile { width: 280px!important; } .post-content .separator.adb-center-on-mobile { text-align: center!important; } .mt-47 img { padding-top: 0; } } /* overwriting styles */ #main .post .post-header .published { margin-bottom: 0; } .post .post-content { margin-top: 5px; }
Posted by Vineet Buch, Director of Product Management, Google Play Apps & Games

Read this in العَرَبِيَّة‎‎, Bahasa Indonesia, Deutsch, español (Latinoamérica), le français, português do Brasil, tiếng Việt, русский язы́к, ไทย, Türkçe, 한국어, 中文 (简体), 中文 (繁體), or 日本語.
Google Play continues to grow rapidly around the world, thanks to our ecosystem of developers building high quality and engaging app experiences. There are now 2 billion monthly active Android devices. People in 190 countries downloaded 82 billion apps from the Play Store in the last year and the number of developers with more than 1 million monthly installs grew by 35 percent year on year. We've made huge investments to make purchasing quick and easy by offering direct carrier billing with 140 operators that reach 900M devices every month. These, and other efforts, have made the number of buyers on Google Play grow by almost 30 percent in the last year.
Since we launched the Google Play Console in 2012, we've continued to add features to help you do much more than just publish apps. People in a variety of roles at app and game companies, large and small, carry out tasks like running beta tests, analyzing crashes, responding to customer reviews, evaluating A/B experiments on store listings, pulling financial reports, and more.
Today at Google I/O, we're announcing new and improved features to help you improve your app's performance and quality, and grow your business on Google Play.




Google Play Console -->
StatisticsUPDATED The statistics page for your app now gives you quicker, more flexible access to important data about your business. Compare two different metrics and break them down by a dimension. Select any date range you want, view a breakdown of your data, and even access hourly stats.






Android vitalsNEW Understand your app's Android vitals so you can fix bad behaviors, improve your app experience, and increase your star rating. View aggregated, anonymized device data from people who have opted in their devices to understand three crucial aspects of your app's performance: stability (crash rates and App Not Responding [ANR] rates), battery usage (stuck wake locks and excessive wakeups), and render time (slow rendering and frozen UI frames). Learn more about Android vitals.


UPDATED The ANRs & crashes page has also been updated with larger crash coverage and now benefits from a higher volume of data.





Release management NEW Use the new release dashboard to track a release as it happens. By monitoring how your release is affecting important metrics, you can be confident that everything is going as planned or you can quickly halt your rollout if anything looks out of the ordinary.



NEW Publish Android Instant Apps with the same release management flow you're familiar with from publishing apps on Google Play. Iterate quickly with a development track, gather feedback from trusted testers on a pre-release track, and when you're ready, release to production. Get started with Android Instant Apps.



NEW The new device catalog will help ensure you're offering a great user experience on the widest range of devices. Search and filter across rich device data for thousands of devices certified by Google. The catalog even shows you your installs, rating, and revenue contributed by device type to help you make the right decisions. You can now also set device exclusion rules by performance indicators like RAM and system on chip. With more granular controls you can exclude fewer devices and offer the best experience on all devices your app supports. Learn more about the device catalog.



NEW For something as important as your app signing key, there's no room for error. With app signing in the Play Console, you now have the option to securely transfer your key to Google to manage on your behalf. You'll benefit from Google's industry leading security and be able to opt-in for upcoming assistive services like app optimizations for APK size. Once opted-in to this service, the Play Store will deliver versions of your APK optimized for the screen density and native architecture of each target device type, saving data and device storage for your users. Learn more about app signing.



UPDATED The pre-launch report, powered by Firebase Test Lab, shows you the results of testing your alpha or beta app on real devices in the lab so you can spot and fix issues before you launch, so they won't affect your rating. The report has been updated with more device test coverage including Android O devices, and new controls, like being able to provide credentials so your app can be tested behind a login.




User acquisitionNEW The acquisition report helps you understand where visitors to your store listing are coming from and whether they go on to install and buy things in your app. The report now includes retained installer data. This reveals which channels and geographies drive valuable users who keep your app installed over periods of up-to 30 days, helping you optimize your marketing efforts.






Financial reportsNEW Subscriptions are the fastest growing business on Google Play – the number of active subscribers has doubled in the last year. With the subscriptions dashboard, see how your subscriptions are performing and make better decisions to grow your business. Understand and analyze total subscribers, revenue, retention, and churn across multiple dimensions.





User feedbackUPDATED Reviews are a valuable channel you can use to engage with people who have your app installed directly. Reviews analysis now covers more languages to help you gather insights from reviews to improve your app. Updated ratings summarizes how users have updated their ratings and reviews, including the effect any replies you made had on those updates. Reviews history shows you the history of your conversation with a user. Finally, we are rolling out the ability to report reviews which do not meet the posting policy guidelines.





Watch us introduce the new Play Console features live at I/O 2017Tune in live to watch the 'What's new in Google Play at I/O 2017' session, which starts at 12:30pm PT on Thursday, May 18. The team is excited to share all the features we've been working on.
--> We're also presenting deeper dives into all of our new features and sharing best practices to help you succeed on Google Play. Watch all the Google Play I/O sessions live or afterwards on YouTube:

Day 1, May 17

Day 2, May 18

Day 3, May 19

And be sure to watch the Google Play Awards on day two, which will once again recognize outstanding developers that continue to set the bar for quality apps and games.


How useful did you find this blogpost?





Categories: Programming

Asking Questions: Many Types Of Questions

CC Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)

Questions are a critical tool that every coach, mentor or leader uses to help shape and improve the performance of those they interact with.  ‘Question’ represents a high-level category that describes many different types of questions.  This is similar to the screwdriver.  If you were to walk into a hardware store and ask for a screwdriver the clerk would ask what kind and/or what you were going to use it for in order to help you find the right kind.  There are different taxonomies of questions which are useful to help practitioners decide what type of question suits which purpose.

Open, Closed and Hybrid Questions:

The first classic categorization typically leveraged when considering which type of question to use in any specific scenario is: open or closed?

 Open questions are queries that have multiple and often conflicting answers.  An example of an open question would be asking someone what the meaning of life (an extreme example).  The primary goal of an open question is to generate a conversation and participation.  Open questions can be used to guide conversations by are not as effective at guiding an interview as a set of closed questions (below).

Closed questions are questions with a limited number of correct answers. For example, a  yes/no question is a closed question.  Another non-yes/no example is the question, Did the sun come up this morning?  The question while yes or noe has one correct answer (unless something very dramatic and bad has occurred and then no one would really care about the answer).  A multiple choice question is another slightly less extreme version of a closed question. Closed questions are good for testing comprehension, but are not very good for generating a conversation.   Another very effective use of closed questions is a tool to guide the direction of a conversation, or a leading question (another taxonomy).  The use of leading questions assumes that the conversion is deterministic, can be mapped, and the person being guided doesn’t react badly to being directed. Lawyers and salesmen use leading questions more often than coaches and mentors.

In many circles when people discuss whether a question is open or closed there is an assumption that open questions are prima facie better than closed and therefore need to be avoided. As with most extremes, this simplification is wrong. Both are useful but their primary purposes are very different.  Using one when the other is indicated tends to yield poor results.

Hybrids that combine open and closed questions try to get the best of both worlds. Asking a yes/no and why is a hybrid approach that is often used to test knowledge while generating a conversation.   I use this type of hybrid approach at the end of every interview I do for the Software Process and Measurement Cast.  I ask the interviewee what are the two (closed) things they would change and why (open). The closed part directs the answerer in a specific direction while the why provides the answerer with an open field to expand on why they think the material is valuable.

ORID Framework

Another method of characterizing questions is the ORID Framework.  ORID is an acronym for:

  • Objective Questions which reveal facts and reality.  These questions are useful for setting the context.
  • Reflective Questions which tease out the relationship between data. Reflective questions tend to focus on the emotional aspect of relationships.
  • Interpretive Questions explore the sense of a situation by promoting critical thinking and analysis.
  • Decisional Questions prompt action.  The questions prompt the person answering the question to examine benefits and the consequences of actions or inaction, and finally to make decisions.

The ORID framework is useful when preparing for a meeting or facilitation session. For example, having a facilitator in a storytelling session for a premortem (a storytelling technique often used for risk management) will need to have a pallet of seed questions developed before the session.  While these questions will be tailored based on the context of the session, having a base to draw from in each category allows the facilitator to focus more on the action than on writing questions on the fly!

Conclusion

In my basement, I have a 10 or 15 screwdrivers.  Each screwdriver is for a specific task, although I have experimented with using many of screwdrivers for other things than what they are supposed to used for.  Sometimes the experiment works, sometimes the experiment fails.  Questions are no different. Every good mentor or facilitator needs to have a pool of questions that can be used in any situation; however just having a pool of questions is not sufficient to be a good interviewer or facilitator.  In order to be sufficient, the questioner needs to know why they are asking the question and the outcome the question is supposed to elicit.

 


Categories: Process Management

Android Announces Support for Kotlin

Android Developers Blog - Thu, 05/18/2017 - 22:38
.prettyprintsmall { font-size: 12pt; } By Mike Cleron, Director, Android Platform

Today the Android team is excited to announce that we are officially adding support for the Kotlin programming language. Kotlin is a brilliantly designed, mature language that we believe will make Android development faster and more fun. It has already been adopted by several major developers — Expedia, Flipboard, Pinterest, Square, and others — for their production apps. Kotlin also plays well with the Java programming language; the effortless interoperation between the two languages has been a large part of Kotlin's appeal.


The Kotlin plug-in is now bundled with Android Studio 3.0 and is available for immediate download. Kotlin was developed by JetBrains, the same people who created IntelliJ, so it is not surprising that the IDE support for Kotlin is outstanding.
In addition to the IDE support, we're announcing a collaboration with JetBrains to move Kotlin into a non-profit foundation. (Kotlin is already open sourced under Apache2.)
Say "Hello" to Kotlin Kotlin will be very familiar to anyone who has used the Java programming language.
package helloWorld

fun main(args: Array) {
   println("Hello World!")
}
At first glance, you will see comforting elements like curly braces, classes, packages, functions and methods. But as you go deeper, you will discover that although Kotlin is based on familiar concepts, it is a uniquely modern, elegant and pragmatic riff on those models. In particular, Kotlin is highly expressive with minimal syntactic friction between your thoughts and what you have to type in order to express those thoughts. If when writing code you have asked yourself questions that began "why do I have to …?" you will be pleased to learn that in Kotlin the answer to many of those questions is "you don't!"
For example, perhaps you have asked why you need to type in a bunch of boilerplate getters and setters as well as overriding equals(), hashCode() and toString() when implementing a simple class. Here is a typical example from the Java programming language (in a microscopic font for brevity).
public class Customer {
   private String name;
   private String email;
   private String company;

   public Customer(String name) {
       this(name, "", "");
   }

   public Customer(String name, String email) {
       this(name, email, "");

   }

   public Customer(String name, String email, String company) {
       this.name = name;
       this.email = email;
       this.company = company;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public String getCompany() {
       return company;
   }

   public void setCompany(String company) {
       this.company = company;
   }

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;

       Customer customer = (Customer) o;

       if (name != null ? !name.equals(customer.name) : customer.name != null) return false;
       if (email != null ? !email.equals(customer.email) : customer.email != null) return false;
       return company != null ? company.equals(customer.company) : customer.company == null;
   }

   @Override
   public int hashCode() {
       int result = name != null ? name.hashCode() : 0;
       result = 31 * result + (email != null ? email.hashCode() : 0);
       result = 31 * result + (company != null ? company.hashCode() : 0);
       return result;
   }

   @Override
   public String toString() {
       return "Customer{" +
               "name='" + name + '\'' +
               ", email='" + email + '\'' +
               ", company='" + company + '\'' +
               '}';
   }
}
In Kotlin, you don't have to type any of that. This single line is equivalent to the entire class above.
data class Customer(var name: String, var email: String = "",
                    var company: String = "")
History and Reference Kotlin has been around for quite a while; it was announced back in 2011 and the first preview was released in 2012. Kotlin 1.0 was released in 2016, at which point JetBrains committed to maintaining backwards compatibility for stable features from 1.0 forward.
You can find excellent training material and references at https://kotlinlang.org/. The Android team has found the Kotlin Koans tutorial to be especially helpful as a quick way to get started writing some Kotlin snippets. These tutorials range from the simple to the sublime as the material progresses from the basics to more sophisticated Kotlin idioms.
Why Kotlin? Why did the Android team decide to support Kotlin? Most importantly, it was because we think Kotlin is a great language that will make writing Android apps easier and more enjoyable.
Kotlin is also a great match for the existing Android ecosystem. It is 100% compatible with the Java programming language. You can add as little or as much Kotlin into your existing codebase as you want and mix the two languages freely within the same project. Calling out to Kotlin code from code written in the Java programming language Just Works™. Going the other direction usually works without any developer effort too via some automatically applied translation conventions (for example, things like property getters and setters are created for you). With the help of a few Kotlin annotations, you can also customize how the translation is performed.
Finally, many, many developers have told us they love the Kotlin language. (Many of our own developers on the Android team have also been saying similar things.) There is already an enthusiastic community of Kotlin developers for Android, and the Android team has been routinely peppered with questions about Kotlin at public events. The Android community has spoken, and we listened.
A Quick Tour To help you get a sense of where all of the excitement around Kotlin is coming from, here is a quick, very-much-not-comprehensive tour of some of the particularly appealing aspects of Kotlin:
Nullable
The Kotlin compiler enforces that variables that can hold null values are explicitly declared – thus no more NullPointerExceptions at runtime!
var neverNull: String = "something"
var mightBeNull: String? = null // "?" indicates this can be null

if (neverNull.length > 0) {   // This is OK
    …
}

if (mightBeNull.length > 0) { // Compiler catches this error for you
    …
}
Named parameters and default arguments
We've all seen methods that have too many parameters to keep track of. For example:
fun orderPizza(size: Size, pepperoni: Boolean, mushrooms: Boolean,
               ham: Boolean, pineapple: Boolean, pickles: Boolean,
               sausage: Boolean, peppers: Boolean, onion: Boolean)
{
    ...
}

// Wait… did I just order pickles on my pizza?
// Why do we even have that option?
orderPizza(Size.LARGE, true, false, false, false, true,
           false, true, false)
Compare that to a similar scenario using named parameters and default arguments:
fun orderPizza(size: Size,
               pepperoni: Boolean = false,
               mushrooms: Boolean = false,
               ham: Boolean = false,
               pineapple: Boolean = false,
               pickles: Boolean = false,
               sausage: Boolean = false,
               peppers: Boolean = false,
               onion: Boolean = false)
{
    ...
}

orderPizza(Size.LARGE, ham = true, mushrooms = true)
In addition to helping to avoid tragic pizza outcomes, this is much easier to read. It also reduces the number of variants of overloaded functions you need to write.
When statement
Kotlin has a variation of a switch statement that allows matching on arbitrary expressions.
// Please don't put this in your app!
when {
    password.equals("password") -> println("Insecure password!")
    password.length < 4 -> println("Too short!")
    else -> {
        println("Secure password!")
    }
}
Smart Casts
Why should you have to cast something to a class right after you just tested that it is an instance of that class? In Kotlin, you don't have to do that anymore.
if (obj is String) {
    // Compiler casts obj to a String for you.
    // (Would work with && instead of nested ifs too.)
    if (obj.length > 0) {
        …
    }
}
This generalizes to the when statement as well:
// Assume reasonable implementations of Cat and Dog
when (obj) {
   is Cat -> obj.meow(...)
   is Dog -> obj.woof(...)
   else -> {
        …
   }
}
Extension functions
Kotlin lets you essentially retcon new methods onto an existing type. If you, like many people, wish that the String class had a toPigLatin method, you can now add it yourself without having to create a new helper class to wrap String or going through the trouble of serving on a language committee:
// The "String." prefix indicates that this method should
// extend the existing String class
fun String.toPigLatin() : String {
    ...
}

val plainOldString : String = "some text"

// Can now call toPigLatin as if were a method on String
println(plainOldString.toPigLatin())

// Or:
println("some text".toPigLatin())
Destructuring Declarations
We have already seen how easy it is to define a simple data class:
data class Order(val itemCode: String, val quantity: Int,
                 val price: Float)
A function that uses one of these classes as the return type is very close to supporting multiple return values:
fun getOrder(...): Order {
    ...
    return Order(itemCode, quantity, price);
}
To get all the way there, you can use the destructuring declaration syntax. The following statement takes the Order object, extracts its three properties, and then assigns them to the three variables what, howMany and howMuch — all courtesy of the Kotlin compiler, which also infers the correct types for you.
val (what, howMany, howMuch) = getOrder(...)
Lambdas
Kotin has an extremely concise syntax for lambdas that makes is easy to express powerful functional programming paradigms. Here's a simple example that uses a lambda to test that everything in a collection is a String:
fun allStrings(collection: Collection)=
    collection.all { it is String }
That lambda syntax is building block of one of Kotlin's coolest features: the ability to create builders that use JSON-like syntax that also happens to be syntactically valid Kotlin. This example is adapted from an extended discussion here, but you can get the flavor of what it possible with this snippet:
fun generatePage(withEmphasis : Boolean) {
    val result =
        html {
            head {
                title { +"Kotlin Builders" }
            }
            body {
                h1 { +"Kotlin Builders" }
                p {
                    +"This is "
                    if (withEmphasis) b { +"really " }
                    +"interesting"
                    a(href = "https://goo.gl/rHwJio") { +"More here" }
                }
            }
        }
    println(result)
}
There are a couple of interesting things going on here. First, this shows how expressive Kotlin's functional syntax can be: in this example, "html", "head", "body, etc. are all just functions written in Kotlin and the stuff in curly braces that follows are functional parameters. (This snippet uses functions with names that match HTML tags to build a representation of a web page, but of course you can use this pattern to build any complex data structure with whatever names you want.) The second interesting thing is the "withEmphasis" conditional. This may look like we are mixing code (if (withEmphasis) …) with data (all the HTML-esque tags), but the "data" here is actually just more code. Since it is all really just code, this lets you build complex data structures using a declarative syntax while also having inline access to the full capabilities of the Kotlin language.
Getting Started If you want to get started with Kotlin, you can start playing with code online immediately here. Just hit the green triangle to compile and run.
To try Kotlin in your app, follow these steps:
  1. Download Android Studio 3.0
  2. Open one of your existing ".java" files
  3. Invoke "Code > Convert Java File to Kotlin File"
The IDE will then walk you through adding Kotlin dependencies into your project, and then convert the code to functionally equivalent Kotlin code. (The IDE will also offer to touch up all of the call sites to the converted class when suitable to be more idiomatic Kotlin such as when static methods are moved to companion objects.)
You can also find a lot more information on how to start using Kotlin on developer.android.com.
Categories: Programming

The Modern Mobile Web: State of the Union

Google Code Blog - Thu, 05/18/2017 - 19:44
Cross posted from the Chromium Blog

Posted by Rahul Roy-chowdhury, VP Product Management, Chrome
What a difference a year makes. Last year at Google I/O, we shared that the mobile web was open for business. New technologies such as AMP and Progressive Web Apps (PWAs) were bringing new capabilities, better performance, and a streamlined workflow to the mobile web.
Fast forward one year later: more than two billion AMP pages have been created and "PWA" has proved to be far more than a buzzword—it’s now the way that many businesses around the world are building for mobile devices. For more details, take a look at the video from Google I/O on the latest mobile web state of the union, or read below on how these technologies are making the modern mobile web mainstream.
Momentum
Summing up all the great success stories from around the world in a single post is a tall order, but here are some highlights.

To improve the performance of Wego's mobile site, the company built AMP pages using amp-install-serviceworker to transition to a fast PWA experience. Average page load time decreased from 12 seconds to less than one second, and conversion rates increased by 95%.


When Forbes rebuilt their mobile website as a PWA, they began by re-thinking what their experience could look like on a phone. Instead of minimally updating their underlying site, Forbes integrated PWA technologies to provide an immersive, app-like experience. They saw immediate improvements and engagement rates have more than doubled since launch.


Ola, the leading cab aggregator in India, built a PWA and noticed that 20% of users who book using their PWA had previously uninstalled their app. By reducing the amount of storage space needed, the PWA allowed them to effectively re-engage with users that otherwise would have been lost.
Another success story is Twitter Lite, a PWA which minimizes data usage, is resilient on unreliable mobile networks, and is less than 1MB of space on a device. Twitter's new mobile experience is also optimized for speed, with up to 30% faster launch times as well as quicker navigation throughout the site. They've found that users are spending 2.7x more time on site, and as a result are seeing 76% more tweets on the new PWA than their previous mobile site. Twitter is seeing incredible re-engagement with 1 million sessions initiated a day from icons added to the Android homescreen.
Polished Experiences
Users expect a lot from their mobile devices, and we've added tons of APIs over the past year to meet that demand. The mobile web can support more use cases and get more done than ever before. A few highlights:
  • Improved Add to Homescreen: Earlier this year we unveiled Improved Add to Homescreen, integrating PWAs much deeper into the Android operating system. Now, in addition to being displayed on the homescreen, PWAs are also displayed in the app launcher and Android settings alongside native apps, and can also open in response to users clicking links in Chrome or other apps.
  • Payments: Checkout can be a complicated process. To improve payment flows on the web, we launched a one-tap payment API called Payment Request. Using this API allows web apps to support credit cards and Google payment mechanisms such as Android Pay. We also just announced that it is now possible to integrate this API with additional payment apps.
  • Media Consumption: Over 70% of internet traffic is video. To allow great mobile web media experiences we have given the users more control over playback with the Media Session API, improved full screen playback with the Screen Orientation API, and we’re filling out features for offline with Background Fetch. To learn more, see our mobile web media best practices and see how the APIs can come together at our PWA for Media demo.
Tooling
We’ve also been working hard to improve and extend the set of tools that let you build engaging experiences on the web.
Lighthouse is a new automated tool for measuring the quality of a web experience. It runs nearly 100 audits against your web app, checking everything from page performance, to byte efficiency, to accessibility, and gives you a summary score. New integration with Chrome's DevTools means you’ll be able to run Lighthouse audits without leaving the browser.
Polymer 2.0 is the next major release of the Polymer library, re-built from the ground up to take advantage of the best new features of the modern web platform. This release uses new Web Component API’s that have shipped in Chrome and Safari. It’s completely modular and best of all - it’s now 10% faster and 80% smaller.
Chrome is committed to making sure that you can develop easily, engage with your users, and build a thriving business around the web. For the latest news, subscribe to our YouTube channel and follow us on Twitter @ChromiumDev.
Categories: Programming

Android Wear: New complications tools and watch friendly UI library

Android Developers Blog - Thu, 05/18/2017 - 18:00
Posted by Hoi Lam, Lead Developer Advocate, Android Wear Android Wear 2.0 gives users more informative watch faces and provides developers with new ways to build useful apps. These new opportunities have been well received by users and developers alike. To help developers take advantage of these new features, we have released a suite of complication API tools, to make it easier for developers to add complication support to their watch faces, and a new Wear UI library, to help developers build watch friendly user interfaces.
New Complications API tools for Watch Face developers

Complications are bite-sized pieces of information displayed directly on the watch face. They can also be great shortcuts into your favorite apps. We introduced the Complications API last year to enable watch faces to receive data from any app that the user selects, and display the data to the user in a way that is stylistically coherent. Today, we are introducing four new tools to make it easier for watch face developers to integrate with the Complications API:

  • TextRenderer - Auto-sizes text to fit in bounds defined by watch face makers.
  • ComplicationDrawable - A full rendering solution for complications, that handles all the styling for you, and adjusts the layout to fit the space you specify
  • Easy watch face settings sample - Adoptable sample code that makes it easier to build complication settings with a rich and usable experience.
  • Complication test suite - A sample data provider to help check that your watch face can handle all the combinations of fields that can make up complication data.

It's never been easier to integrate complications into your watch faces.

New Wear UI Library for Wear developers

We have provided Android view components for building watch friendly user interfaces since the launch of Android Wear 1.0. Developers have told us that they would like to see these components open sourced. So, starting at Google I/O, we are open sourcing some components and providing some Android Wear UI components in the Android Support Library. This brings a number of advantages, including more consistent APIs with the rest of the Support Library, more frequent releases, and better responsiveness to developer feedback. We will:

  • Migrate Wearable Support classes - Migrate and update Android Wear specific view components, such as WearableRecyclerView, from android.support.wearable.view in Wearable Support to android.support.wear.widget in the Android Support Library. This new package is available as open source. In terms of developer impact, we expect the migration process to be simple, with minor API name changes to bring consistency with the existing Android Support Library.
  • Merge some Android Wear functionality to Android - Some Android Wear components have a lot of overlap with Android, e.g. CircledImageView and DelayedConfirmationView. We will merge the Android Wear specific functionality with the Android counterparts under android.support.v4.widget.
  • Deprecate outdated user interface patterns - Two user interface patterns are deprecated with Android Wear 2.0: the Card pattern and the Multi-directional layout. As a result, we have deprecated all supporting classes, such as GridViewPager and CardFragment. Please refer to the class reference docs for their replacements.

In the first wave of these changes, we migrated the WearableRecyclerView, BoxInsetLayout and SwipeDismissFrameLayout classes to the new Android Wear UI Library. We expect the migration process to continue during 2017, and developers will have until mid-2018 to migrate to the new UI components. For additional information, see Using the Wear UI Library.

Get started and give us feedback!

To get started with these new tools, simply update the Android Support Library in Android Studio and update your gradle build files to import the new support libraries. In addition to the documentation links above, check out the Google I/O session - Android Wear UI development best practice - where lead engineers for these tools will be on-hand to explain the technical details.

We will continue to update these tools over the next few months, based on your feedback. The sooner we hear from you, the more we can include, so don't be shy! Let us do some of the heavy lifting for your Android Wear apps and watch faces.

Categories: Programming

Five Immutable Principles of Project Success and Estimating

Herding Cats - Glen Alleman - Thu, 05/18/2017 - 16:30

Let's start with a fundamental principle of all project management...

Risk Management is How Adults Manage Projects - Tim Lister

All risk comes from Uncertainty - reducible uncertainty and irreducible uncertainty. [1] No uncertainty No Risk. 

If you're not managing risks You're not managing the project. In order to manage risk - and act as an adult when spending other people's money - you must estimate many aspects of the project. The Five Immutable Principles of Project Success layout the aspects of project success that must be managed using estimates.  

Screen Shot 2017-05-16 at 3.59.22 PM

These Five Immutable Principles are found on all successful projects.

There was a question asked on Twitter -what do estimates have to do with these Principles?

Here are some answers. These answers are found in our Processes and Practices guide that accompany the Principles of project success. They are just the bullet points of good project management no matter the development method - traditional or agile.

  1. What does Done look like?
    • Done must be described in units of measure meaningful to the decision makers. These units start with Measures of Effectiveness and Measures of Performance.
    • These measures are rarely fixed or deterministic. They have upper and lower control limits for their evolving stochastic behavior.
    • The planned and certainly desired behaviors of the project should operate inside these limits. The role of management is the plan and control the behaviors of the cost, schedule, and technical aspects of the project. 
    • As well these behaviors evolve over time, increasing in their compliance with the upper and lower control limits, which are reducing toward the desired values as the project progresses. This is the Cone of Uncertainty paradigm.
    • Estimating the behavior of these parameters is needed to forecast what might be the expected behaviors to assess what responses will be needed if they were to occur.
    • Estimating the impacts of any decisions made when taking corrective actions to keep the program GREEN (inside the upper and lower control limits)
    • In the domain I work - our department is called Program Planning and Controls. Control in the presence of uncertainty is Closed Loop. It doesn't always turn out well, but the principles, processes, and practices of Closed Loop Program Planning and Control are well established.
    • When it goes bad, corrective actions are needed after the Root Cause of the unfavorable variance is determined.
    • Program Planning and Controls is a Close Loop Control process. Estimating is needed for Close Loop Control.
  2. How do we get to Done?
    • The path to Done is described in Plans and Schedules of the work that implement those Plans.
    • Each step along the way follows a path that is probabilistic since all project attributes are themselves random values.
    • Controlling that path - in the presence of uncertainty - means making estimates of the possible outcomes of any decision. 
  3. Is there enough time, money, and resources to get to Done?
    • Each of these variables is a random variable with a probability distribution. These distributions have a Mode (Most Likely) and there upper and lower limits and the shape of the curve.
  4. What impediments will be encountered along the way to Done?
    • Risk Management is How Adults Manage Projects - Tim Lister
    • All project risks come from uncertainty. These uncertainties come in two form - Reducible and Irreducible.
    • Reducible uncertainty requires specific reduction activities. This work operates in the presence of uncertainty itself. Estimates are needed to assess the probability processes of these uncertainties.
    • Irreducibility uncertainty requires margin. This margin is developed with a probability model
  5. What are the units of measure for progress to plan for each deliverable?
    • Measures of effectiveness and performance have uncertainties in both the measurement - an epistemic uncertainty. And an uncertainty in the actual performance - an aleatory uncertainty. 
    • The accuracy and precision of the measures also impact the confidence of the measurement.
    • Estimating both is these is needed to assure proper performance measures are provided to the decision makers.

[1] "Distinguishing Two Dimensions of Uncertainty," Craig Fox and Gulden Ulkumen, in Perspectives of Thinking and Decision Making

Related articles Who's Budget is it Anyway? Essential Reading List for Managing Other People's Money Monte Carlo Simulation of Project Performance Estimating Processes in Support of Economic Analysis The Fallacy of the Planning Fallacy Herding Cats: How to Talk About Estimates Root Cause of Project Failure
Categories: Project Management