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

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

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

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

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

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

Methods & Tools

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

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

Agile Portfolio Metrics Categories

532154894_d077e58fbf_z

Portfolio provide direction

The term portfolio has many uses in a software development organizations, ranging from product portfolios to application portfolios.  I have even seen scenarios in which organizations put all their development, enhancement and maintenance efforts into a single bucket for prioritization and queuing until there was the capacity to work on them.  We will use an inclusive definition of the portfolio to include, at a high level, all the software development and enhancement work in an organization.  The definition of the term organization is flexible, and can be defined to meet any specific reporting and control needs.  Products, lines or business, and even applications are often used to define portfolios. Agile portfolio metrics are integral to prioritization and validating the flow of work.  I break Agile portfolio metrics into five high-level categories.

  1. Portfolio Mix metrics provide portfolio managers and the organization with an understanding of how the organization allocates work across different teams or classes of service.  For example, one organization I have worked with classifies the work in their portfolio as innovation (big bets that might leapfrog competitors), grow the business (extensions of current applications or products), run the business (work that maintains current products or applications) and expedited (high priority or squeaky wheel).  Data for this category is often “harvested” from the business cases.
  2. Demand and Capacity metrics provide feedback on the organizational capacity and the demand placed on the capacity. Metrics are often focused on flow and might include work-in-process limits and value flow.  Much of the data for metrics in this category is captured based on the observing the movement of work through the portfolio lifecycle.
  3. Value metrics provide feedback on the economic value work in and delivered from the portfolio. Data for these metrics comes from market share data and accounting data, including the cost of work performed, sales, margin contribution, and cost avoidance.
  4. Portfolio Health metrics provide feedback on how satisfied stakeholders and team members are with the work performed. Health metrics often use satisfaction surveys (customer and team), net promoter scores and quantified risk metrics as a sign of portfolio health.  One organization I recently observed measures backlog age as a proxy for portfolio health.  Satisfaction data is often gathered via survey tools, while risks data comes from calibrated estimates identified for the work.
  5. Financial Management metrics leverage funding and budget information.  The data comes from accounting systems and project tracking systems, depending on where the work is in the portfolio lifecycle.

Agile portfolio metrics are only useful if they provide value. As our re-read of Hubbard’s How to Measure Anything has made plain, just because we measure something, does not mean we should. All measure must have economic value or they are not useful.  Metrics and measures add value if they reduce uncertainty so that we can make better decisions.  The five categories of metrics are targeted at providing data for different decisions (which will be explored next).


Categories: Process Management

My Book Tour in North America

NOOP.NL - Jurgen Appelo - Tue, 02/09/2016 - 22:20

This year in June, publisher John Wiley & Sons will release Managing for Happiness, the updated version of my very successful #Workout book. To celebrate this, I have a special offer for event organizers in the USA and Canada.

For an appearance at any event (either public or in-company) during my book tour, I offer 100 copies of my new book for free, and for anything above that number, I offer a 50% discount from the catalog price (USD 35)

The post My Book Tour in North America appeared first on NOOP.NL.

Categories: Project Management

App Monetization Insights: How Hydro Coach rapidly reached 22 new markets

Google Code Blog - Tue, 02/09/2016 - 20:30
We created The No-nonsense Guide to App Monetization to help you answer a burning question, “What’s the best way to monetize my app?”. Our new 5-part blog series provides additional tips straight from successful app developers.

Hydro CoachThis week, meet Christoph Pferschy, the app developer and designer behind Hydro Coach. Hydro Coach is a drink reminder and water intake tracker that’s been growing in popularity, now receiving over 5,500 downloads a day. Check out these tips from Christoph.

1. Start small to get big
Christoph is best known for his app Hydro Coach, but his company, Codium App Ideas, has a bigger vision. In his words, they’re on a mission “to create useful and high-quality health-related apps that are combinable to a single health & fitness system.”

But right now, Christoph is focusing on just one app – Hydro Coach. Why?

Because he believes the best way to accomplish a big goal is to focus on a critical piece and nail it. He chose Hydro Coach because he’s personally benefited from drinking more water and he saw that there was less competition in the space.

Now that his business is growing, he’s begun moving forward with his larger plan, connecting with other services and platforms. For example, he explains, “we’ve connected Hydro Coach to Google Fit to synchronize users’ weight and we’re also very proud to be featured as a partner app with Samsung’s S Health,” syncing all drink inputs with their platform.”

Consider Christoph’s approach to building a company: start small to get big. Focusing on too much, too early, might not allow you to build an app experience that user’s love.

2. Assess users’ needs before choosing a business model
Settle on a business model for your app before it launches. Spend time assessing your users’ needs and your business goals to get there. Start by asking yourself guiding questions that will help narrow down the decision for you like, “Who is your audience?”, “What value does your app provide?”, and “How do you intend to promote your app?”. Learn more about these guiding questions and business models in our No-nonsense Guide to App Monetization.

Once you do choose your business model, consider continually improving your app’s user experience, especially when it affects monetization. Christoph is meticulous about providing the best experience for all of his users, explaining,

“We try to improve each user experiment segment with small and careful changes over time. For example, we’ve fine-tuned the algorithm that determines when, how and how often ads are displayed, thanks to Manuela (our AdMob consultant). We also invest in small things that mean a lot to our users, like being sure to say ‘Thank you’ after a user makes an in-app purchase and making the flow after a purchase as smooth as possible. It all adds up.”

As you look through your app, be methodical when choosing your overarching monetization strategy. Once you’ve chosen your model, focus on tweaking the user experience and providing the best possible monetization flow.

3. Consider having your users help with localization
Christoph has done an amazing job getting Hydro Coach fully translated into 22 languages. His secret weapon? His users.

As he explains, “It’s no secret that translating the app is the first and most important step. So here’s my tip: ask your users to help translate. It results in a high-quality translation because people who are already using your app have the needed context and interest. There are several services for this that you can use, but you’ll be surprised how many people love to help.”

If you found these tips helpful, don’t forget to check out The No-nonsense Guide to App Monetization. Also, stay connected on all things AdMob by following our Twitter and Google+ pages.

Posted by Joe Salisbury, Product Specialist, AdMob

Categories: Programming

A Smallish List of Parse Migration Guides

Since Parse's big announcement it looks like the release of migration guides from various alternative services has died down. 

The biggest surprise is the rise of Parse's own open source Parse Server. Check out its commit velocity on GitHub. It seems to be on its way to becoming a vibrant and viable platform.

The immediate release of Parse Server with the announcement of the closing of Parse was surprising. How could it be out so soon? That's a lot of work. Some options came to mind. Maybe it's a version of an on-premise system they already had in the works? Maybe it's a version of the simulation software they use for internal testing? Or maybe they had enough advanced notice they could make an open source version of Parse? 

The winner is...

Charity Majors, formerly of Parse/Facebook, says in How to Survive an Acquisition, tells all:

Massive props to Kevin Lacker and those who saw the writing on the wall and did an amazing job preparing to open up the ecosystem.

That's impressive. It seems clear the folks at Parse weren't on board with Facebook's decision, but they certainly did everything possible to make the best out of a bad situation. It's even possible this closure could be a good thing for Parse in the long run if open source support continues to flourish.

Here's a list of different ways of getting from here to there...

Migration Guides
Categories: Architecture

Should Scrum Teams Include a Stretch Goal In Their Sprints?

Mike Cohn's Blog - Tue, 02/09/2016 - 16:00

There are, of course, a variety of ways to go about planning a sprint. I’ve written previously about velocity-driven sprint planning and commitment-driven sprint planning and my preference. But regardless of which approach a team takes to sprint planning, there is also the question of how full to fill the sprint.

Some teams prefer to leave plenty of excess capacity in each sprint, perhaps so there is time for emergent needs or experimentation. Other teams prefer to fill the sprint to the best of their ability to forecast their capacity.

Still other teams like to take on a “stretch goal” each sprint, which is kind of a product backlog item that is not quite in the sprint, but is one the team hopes to complete if the sprint goes well.

In this post, I’d like to share my thoughts on bringing a stretch goal into a sprint.

This is one of those things that needs to be left entirely up to the team. It should not be up to the ScrumMaster or the product owner, but up to the team. Some teams do extremely well with a stretch goal. Other teams do not.

It really depends on how the team views the stretch goal.

For example, I feel stretch goals are like a crushing weight. I feel like I need to complete them. When I set a goal, I almost always achieve it. I have a hard time distinguishing between what I call a “normal goal” and stretch goal. I don’t think this is good, but it’s who I am. But, I’m not the only one who does this.

If a team included me and perhaps a couple of others like me, we would probably not do well with a stretch goal. The stretch goal would likely be in our minds and possibly even affect our ability to finish all of the main work of the sprint.

Other people--those unlike me--have what I’ll call a more mature attitude toward stretch goals. They can look at it as it’s intended. They can think, “OK, great if we get to it but no big deal if not.” Teams comprising mostly people like that will probably do quite well with a stretch goal.

So: Should your team have a stretch goal in their sprints?

This really has to be up to the team. Unless I’m on the team. Then the answer is no.

Does Your Team Use Stretch Goals?

What do you do? Does your team use stretch goals? Does it help? Please share your thoughts in the comments below.

Managing Programmers

From the Editor of Methods & Tools - Tue, 02/09/2016 - 15:24
Programmers are not like the other kids. They cannot and should not be managed like normal people if your intent is to produce high quality software. The things you would do to make the process go faster will actually make things go slower. This session gives you insight on the care and feeding of programmers, […]

Thinking About Servant Leadership and Agile Project Management

For many people, agile means an end to all project management. I disagree. I find value in servant leadership in project management.

I explain how you can think about servant leadership and agile project management in my projectmanagement.com column this month: Servant Leadership: The Agile Way.

If you are looking to increase your servant leadership and help your project team (or program), check out the Influential Agile Leader.

Categories: Project Management

Automated UI Testing with React Native on iOS

Xebia Blog - Mon, 02/08/2016 - 21:30
code { display: inline !important; font-size: 90% !important; color: #6a205e !important; background-color: #f9f9f9 !important; border-radius: 4px !important; }

React Native is a technology to develop mobile apps on iOS and Android that have a near-native feel, all from one codebase. It is a very promising technology, but the documentation on testing can use some more depth. There are some pointers in the docs but they leave you wanting more. In this blog post I will show you how to use XCUITest to record and run automated UI tests on iOS.

Start by generating a brand new react native project and make sure it runs fine:
react-native init XCUITest && cd XCUITest && react-native run-ios
You should now see the default "Welcome to React Native!" screen in your simulator.

Let's add a textfield and display the results on screen by editing index.ios.js:

class XCUITest extends Component {

  constructor(props) {
    super(props);
    this.state = { text: '' };
  }

  render() {
    return (
      <View style={styles.container}>
        <TextInput
          testID="test-id-textfield"
          style={{borderWidth: 1, height: 30, margin: 10}}
          onChangeText={(text) => this.setState({text})}
          value={this.state.text}
        />
        <View testID="test-id-textfield-result" >
          <Text style={{fontSize: 20}}>You typed: {this.state.text}</Text>
        </View>
      </View>
    );
  }
}

Notice that I added testID="test-id-textfield" and testID="test-id-textfield-result" to the TextInput and the View. This causes React Native to set a accessibilityIdentifier on the native view. This is something we can use to find the elements in our UI test.

Recording the test

Open the XCode project in the ios folder and click File > New > Target. Then pick iOS > Test > iOS UI Testing Bundle. The defaults are ok, click Finish. Now there should be a XCUITestsUITests folder with a XCUITestUITests.swift file in it.

Let's open XCUITestUITests.swift and place the cursor inside the testExample method. At the bottom left of the editor there is a small red button. If you press it, the app will build and start in the simulator.

Every interaction you now have with the app will be recorded and added to the testExample method, just like in the looping gif at the bottom of this post. Now type "123" and tap on the text that says "You typed: 123". End the recording by clicking on the red dot again.

Something like this should have appeared in your editor:

      let app = XCUIApplication()
      app.textFields["test-id-textfield"].tap()
      app.textFields["test-id-textfield"].typeText("123")
      app.staticTexts["You typed: 123"].tap()

Notice that you can pull down the selectors to change them. Change the "You typed" selector to make it more specific, change the .tap() into .exists and then surround it with XCTAssert to do an actual assert:

      XCTAssert(app.otherElements["test-id-textfield-result"].staticTexts["You typed: 123"].exists)

Now if you run the test it will show you a nice green checkmark in the margin and say "Test Succeeded".

In this short blogpost I showed you how to use the React Native testID attribute to tag elements and record and adapt a XCUITest in XCode. There is a lot more to be told about React Native, so don't forget to follow me on twitter (@wietsevenema)

Recording UI Tests in XCode

Quote of the Day

Herding Cats - Glen Alleman - Mon, 02/08/2016 - 21:17

They constructed ladders to reach to the top of the enemy's wall, and they did this by calculating the height of the wall from the number of layers of bricks at a point which was facing in their direction and had not been plastered. The layers were counted by a lot of people at the same time, and though some were likely to get the figure wrong  the majorly would got it right .... Thus, guessing what the thickness of a single brick was, they calculated how long their ladder would have to be. - Thucydides, The Peloponnesian War

So when you hear, we don't need to estimate to know when we're done, that willfully ignores all the naturally occurring variances and the event based variances in all our project work. The Greeks knew this, we need to heed their advice.

Categories: Project Management

What's Next? The NFL's Magic Yellow Line Shows the Way to Augmented Reality

 

Update: Amazon just released Lumberyard, a free AAA game engine deeply integrated with AWS & Twitch.

What’s next? Mobile is entering its comforting middle age period of development. Conversational commerce is a thing, a good thing, but is it really a great thing?

What’s next may be what has been next for decades: Augmented reality (AR) (and VR). AR systems will be here sooner than you might think. A matter of years, not decades. Robert Scoble, for example, thinks Meta, an early startup in AR industry, will be bigger than the Macintosh. More on that in a later post. Magic Leap has no product and $1.3 billion in funding. Facebook has Oculus. Microsoft has HoloLens. Google may be releasing a VR system later this year. Apple is working on VR. Becoming the next iPhone is up for grabs.

AR is a Huge Opportunity for Programmers and Startups 

This is a technological revolution that will be bigger than mobile. Opportunities in mobile for developers have largely played out. Experience shows the earlier you get in on a revolution the better the opportunity will be. Do you want to be writing free iOS apps forever?

It’s so early we don’t really have an idea what AR is or what the market will be or what it means from a developer perspective. But if you watched the Super Bowl you saw an early example of the power of AR. It’s the benign looking, yet technically impressive, computer generated yellow first down line marker.

Augmented Reality is Already a Sports Reality
Categories: Architecture

Pebble Steel Review: 4 Months of a Vibrating Arm

Making the Complex Simple - John Sonmez - Mon, 02/08/2016 - 14:00

I’m seeing smartwatches of various kinds on different people more frequently now. In fact, current market statistics suggest that you can see a smartwatch on 4-6 million people. I’m having a hard time finding direct statistics that I can rely on accurately, but suffice it to say—smartwatches have a strong foothold in our economy. I […]

The post Pebble Steel Review: 4 Months of a Vibrating Arm appeared first on Simple Programmer.

Categories: Programming

Making Agile even more Awesome. By Nature.

Xebia Blog - Mon, 02/08/2016 - 11:31

Watching the evening news and it should be no surprise the world around us is increasingly changing and is becoming too complex to fit in a system we as humankind still can control.  We have to learn and adapt much faster solving our epic challenges. The Agile Mindset and methodologies are an important mainstay here. Adding some principles from nature makes it even more awesome.

In organizations, in our lives, we are in a constant battle “beating the system”.  Steering the economy, nature, life.  We’re fighting against it, and becoming less and less successful in it.  What should change here?

First, we could start to let go the things we can’t control and fully trust the system we live in: Nature. It’s the ultimate Agile System, continuously learning and adapting to changing environments.  But how?

We have created planes and boats by observing how nature did it: Biomimetics.  In my job as an Agile Innovation consultant, I’m using these and other related principles:

  1. Innovation engages in lots of experimentation: life creates success models through making mistakes, survival of the fittest.
  2. Continuously improve by feedback loops.
  3. Use only the energy you need. Work smart and effective.
  4. Fit form to function. Function is primary important to esthetics.
  5. Recycle: Resources are limited, (re)use them smart.
  6. Encourage cooperation.
  7. Positivity is an important source of energy, like sunlight can be for nature.
  8. Aim for diversity. For example, diverse problem solvers working together can outperform groups of high-ability problem solvers.
  9. Demand local expertise, to be aware of the need of local differences.
  10. Create a safe environment to experiment. Like Facebook is able to release functionality every hour for a small group of users.
  11. Outperform frequently to gain endurance and to stay fit.
  12. Reduce complexity by minimizing the number of materials and tools.For example, 96% of life on this planet is made up of six types of atoms: Carbon, Hydrogen, Oxygen, Nitrogen, Phosphorus and Sulphur
How to kickstart your start-up?

Until a couple of years ago,  innovative tools were only available for financial powerful companies.  Now, innovative tools like 3D printing and the Internet of Things are accessible for everybody.  The same applies for Agile.  This enables you to enter new markets against extreme low marginal costs.  In these start-ups you can recognize elements of natural agility.  A brilliant example is Joe Justice’ WikiSpeed. In less than 3 months he succeeded in building a 100 Mile/Gallon street legal car defeating companies like Tesla.  This all shows you can solve apparently impossible challenges by trusting on your natural common sense.  It's that simple.

Paul Takken (Xebia) and Joe Justice (Scrum inc.) are currently working together on several global initiatives coaching governments and large enterprises in reinventing themselves how they can anticipate on today's epic challenges.  This is done by a smarter use of people’s talents, tooling, materials and Agile- and Lean principles as mentioned above.

Spamcast 380 - Kim Robertson, The Big Picture of Configuration Management

Software Process and Measurement Cast - Sun, 02/07/2016 - 23:00

Software Process and Measurement Cast 380 features our interview with Kim Robertson. Kim and I talked about big picture configuration management.  Without good configuration managements work, products, and programs often go wildly astray. Kim describes the a process that is as old a dirt . . . but WORKS and delivers value. We also discussed the book Kim co-authored with Jon Quigley (Jon was interviewed in SPaMCAST 346) Configuration Management: Theory, Practice, and Application.

Kims Bio

Kim Robertson is a NDIA Certified Configuration Management (CM) practitioner, consultant, and trainer with over 30 years of experience in contracts, subcontracts, finance, systems engineering and configuration management. He has an advanced degree in organizational management with a government contracts specialty and is the co-author of Configuration Management: Theory Practice and Application. He can be reached at Kim.Robertson@ValueTransform.com

If you are interested in the seed questions used to frame our interview please visit the SPaMCAST Facebook page.

Re-Read Saturday News

We continue the re-read of How to Measure Anything, Finding the Value of “Intangibles in Business” Third Edition by Douglas W. Hubbard on the Software Process and Measurement Blog. In Chapter Eight, we begin the transition from what to measure to how to measure.

Upcoming Events

I am facilitating the CMMI Capability Challenge. This new competition showcases thought leaders who are building organizational capability and improving performance. Listeners will be asked to vote on the winning idea which will be presented at the CMMI Institute’s Capability Counts 2016 conference.  The next CMMI Capability Challenge session will be held on February 17 at 11 AM EST.

http://cmmiinstitute.com/conferences#thecapabilitychallenge

I will be at the QAI Quest 2016 in Chicago beginning April 18th through April 22nd.  I will be teaching a full day class on Agile Estimation on April 18 and presenting Budgeting, Estimating, Planning and #NoEstimates: They ALL Make Sense for Agile Testing! on Wednesday, April 20th.  Register now

Next SPaMCAST

The next Software Process and Measurement Cast features our essay on Agile adoption.  Words are important. They can rally people to your banner or create barriers. Every word communicates information and intent. There has been a significant amount of energy spent discussing whether the phrase ‘Agile transformation’ delivers the right message. There is a suggestion that ‘adoption’ is a better term. We shall see!

We will also have an entry from Gene Hughson’s Form Follows Function Blog. Gene will discuss his blog entry, Seductive Myths of Greenfield Development. And a visit from the Software Sensei, Kim Pries!  Kim’s essay is on women in the tech field.

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 380 – Kim Robertson, The Big Picture of Configuration Management

 www.spamcast.net

http://www.spamcast.net

Listen Now

Subscribe on iTunes

Software Process and Measurement Cast 380 features our interview with Kim Robertson. Kim and I talked about big picture configuration management.  Without good configuration managements work, products, and programs often go wildly astray. Kim describes the a process that is as old a dirt . . . but WORKS and delivers value. We also discussed the book Kim co-authored with Jon Quigley (Jon was interviewed in SPaMCAST 346) Configuration Management: Theory, Practice, and Application.

Kims Bio

Kim Robertson is a NDIA Certified Configuration Management (CM) practitioner, consultant, and trainer with over 30 years of experience in contracts, subcontracts, finance, systems engineering and configuration management. He has an advanced degree in organizational management with a government contracts specialty and is the co-author of Configuration Management: Theory Practice and Application. He can be reached at Kim.Robertson@ValueTransform.com

If you are interested in the seed questions used to frame our interview please visit the SPaMCAST Facebook page.

Re-Read Saturday News

We continue the re-read of How to Measure Anything, Finding the Value of “Intangibles in Business” Third Edition by Douglas W. Hubbard on the Software Process and Measurement Blog. In Chapter Eight, we begin the transition from what to measure to how to measure.

Upcoming Events

I am facilitating the CMMI Capability Challenge. This new competition showcases thought leaders who are building organizational capability and improving performance. Listeners will be asked to vote on the winning idea which will be presented at the CMMI Institute’s Capability Counts 2016 conference.  The next CMMI Capability Challenge session will be held on February 17 at 11 AM EST.

http://cmmiinstitute.com/conferences#thecapabilitychallenge

I will be at the QAI Quest 2016 in Chicago beginning April 18th through April 22nd.  I will be teaching a full day class on Agile Estimation on April 18 and presenting Budgeting, Estimating, Planning and #NoEstimates: They ALL Make Sense for Agile Testing! on Wednesday, April 20th.  Register now!

Next SPaMCAST

The next Software Process and Measurement Cast features our essay on Agile adoption.  Words are important. They can rally people to your banner or create barriers. Every word communicates information and intent. There has been a significant amount of energy spent discussing whether the phrase ‘Agile transformation’ delivers the right message. There is a suggestion that ‘adoption’ is a better term. We shall see!

We will also have an entry from Gene Hughson’s Form Follows Function Blog. Gene will discuss his blog entry, Seductive Myths of Greenfield Development. And a visit from the Software Sensei, Kim Pries!  Kim’s essay is on women in the tech field.

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, 02/07/2016 - 03:56

One's originality comes in your inability to emulate your influencers - Dale Watson

Categories: Project Management

How To Measure Anything, Chapter 8: The Transition: From What to Measure to How to Measure

HTMA

How to Measure Anything, Finding the Value of “Intangibles in Business” Third Edition

Chapter 8 of How to Measure Anything, Finding the Value of “Intangibles in Business” Third Edition, begins the third section of the book.  Part III is focused on Measurement Methods.  Chapter 8 is titled, The Transition: From What to Measure to How to Measure. This is where you roll up your sleeves, crack your knuckles and get to work. Whenever you are beginning something new, the question of where to start emerges.  If I were to summarize the chapter in three sentences I would say:

  1. Understand the concepts of measurement and error.
  2. Break what you are measuring down into smaller pieces.
  3. Never reinvent the wheel; research how others have measured what you are interested in measuring.

In measurement, we collect data by observing something happening. Our instruments could be a survey, an experiment, a gauge, or many other mechanisms. Instruments have varying levels of precision.  For example, measuring the components of water using chromatography is far more precise than an employee attitude survey. Your choice of instrument will be driven by how much uncertainty the measurement needs to remove.   Remember the goal of measurement is to reduce uncertainty to an acceptable level.  We use standardized instruments because they are consistent and can be calibrated to account for certain types of error.  For example, a colleague developed a sizing instrument for software that was always 12% low when compared to a full IFPUG function point count. Knowing the error allowed him to calibrate the instrument.

Some variables are hard to measure because they represent a nebulous concepts or processes such as the value of information technology.   Decomposition is a step that starts with the variable you want to measure and then breaks it down into its component parts. That way you can identify where there is uncertainty, which parts are observable, which are “easy” to measure and which parts have value.  As noted in Chapter 7, not everything that is measurable has economic value.  Hubbard points out that there is a decomposition effect.  The effect is that as we decompose a metric it is possible to learn enough not to need new observation. Quoting Hubbard:

“The entire process of decomposition itself is a gradual conceptual revelation for those who think that something is immeasurable.”

It is easy to fall into the trap of believing that your measurement problem is unique. Hubbard suggests that we start the measurement process with the assumption that someone else done this before us.  If someone has developed a measurement solution (or close) for what we need, then we can tap into those ideas with some research.  The internet and library provide a rich source of secondary sources. Start by searching on your topic while including terms that will help filter fluff articles.  For example, if you are looking for information on measuring software productivity include terms like data, correlation or tables to the search criteria.  Consider trolling the reference links in Wikipedia articles.  Also, consider reviewing the bibliographies of somewhat related articles.

Once the research has been done observations need to be made to collect data. One technique for determining how to measure, as suggested by Hubbard, is to describe in detail how you see or detect the object being measured. This step is not always easy, especially for anyone that believes any specific object or concept can’t be measured. One the important pieces of advice from Hubbard in when generating a description is difficult, is that if you have any basis for the belief that an object exists, you are observing it.  Describing how you or detect something will provide a strong sign of how to observe the variable.  Determining where to start measuring is like hunting for the first few pieces of a jigsaw puzzle (the fun kind – not the one my wife has going that is just varieties of green and gray).

Here are some of the questions that Hubbard uses to begin:

  • Does it leave a trail of any kind? Almost all phenomena or processes generate some evidence that they occur.  For example, seeing a contrail is evidence that jet has passed overhead.
  • If the trail doesn’t already exist, can you observe it directly or at least, a sample of it? I am often struck by the shock on people’s faces when I suggest that they actually go and observe what is happening. Early in my career in process improvement, we had data at showed a large productivity fall off in key punch operators beginning 30 minutes before lunch.  We had no audit trail that “told” us what was happening and did not understand until we actually watched and measured what was happening.  Let’s leave the answer at a poor application design and move on.
  • If it doesn’t appear to leave behind a detectable trail of any kind, and direct one time observations do not seem workable, can you devise a way to begin to track it now? For example, the EU built the Large Hadron Collider to discover and the Higgs boson particle.
  • If tracking the existing conditions doesn’t suffice, can you force the phenomena to occur under conditions that allow easier observation? Experimentation in the corporate environment is not always easy and often times are not perceived as fair.  Remember, when experimenting on projects fairness issue might be as broad as who is allowed to participate in the experiment or as nitpicky as why team members are asked to expend effort on collecting extra data. Dan Airily, of the Wall Street Journal, in a recent blog addressed the fairness issue noting across an organization (or between teams), “ If you can figure out how to frame them as fair, they might become more palatable.”

All measurements include error.  There are two basic types of error. Systematic are those that are consistent and not just random variations from one observation to the next.  The error in the software measurement example earlier represents a systematic error.  You can account for systematic error through careful calibration.  The second type of error is random error.  Individual observations influenced by random error can’t, by definition, be precisely predicted. Understanding the amount and types of error present in any measurement affects its value.  While you can’t remove all error, that does not mean that you should not understand (mathematically) the error present and to get rid of the amount of error that is economically feasible.

Measurement done on a formal, systematic basis provides information that has value for making decisions.  A colleague has a business that, as a third party, measures the amount of software produced by a development organization and delivered to the client.  Based on that size the client pays the producer. In this example, measurement is used to make a payment decision (and often the estimated size is used to make a purchasing decision). All parties monitor the amount of systemic and random error in the transaction so that the cost and precision meet the need of all parties.  In earlier installments we discussed the economic value of perfect information (EVPI), in this example, I have been told that my colleague and his clients have discussed the EVPI of the information and that the actual cost is far below the EVPI.  The goal is to measure just enough to reduce their uncertainty in the transaction to acceptable levels by focusing on the observable portion of the transaction that is relevant to both parties.  I suspect that they all read this chapter before agreeing on what to measure.

Previous Installments in Re-read Saturday, How to Measure Anything, Finding the Value of “Intangibles in Business” Third Edition

  1. How To Measure Anything, Third Edition, Introduction
  2. Chapter 1: The Challenge of Intangibles
  3. Chapter 2: An Intuitive Measurement Habit: Eratosthenes, Enrico, and Emily
  4. Chapter 3: The Illusions of Intangibles: Why Immeasurables Aren’t
  5. Chapter 4: Clarifying the Measurement Problem
  6. Chapter 5: Calibrated Estimates: How Much Do You Know Now?
  7. Chapter 6: Quantifying Risk Through Modeling
  8. Chapter 7: Quantifying The Value of Information

Categories: Process Management

Agile at Scale - A Reading List (Update 9)

Herding Cats - Glen Alleman - Sat, 02/06/2016 - 19:30

Screen Shot 2015-11-30 at 8.59.46 AMI'm working two programs where Agile at Scale is the development paradigm. When we start an engagement using other peoples money, in this case the money of a sovereign, we make sure everyone is on the same page. When Agile at Scale is applied, it is usually applied on programs that have tripped the FAR 34.2/DFARS 234.2 levels for Earned Value Management. This means $20M programs are self assessed and $100M and above are validated by the DCMA (Defense Contract Management Agency).

While these programs are applying Agile, usually Scrum, they are also subject to EIA-748-C compliance and a list of other DID's (Data Item Description) and other procurement, development, testing, and operational guidelines . These means there are multiple constraints on how the progress to plan is reported to the customer - the sovereign.

These programs are not 5 guys at the same table as their customer exploring what will be needed for mission success when they're done. These programs are not everyone's cup of tea, but agile is a powerful tool in the right hands of Software Intensive System of Systems for Mission Critical programs. Programs that MUST, deliver the needed Capabilities, at the Needed Time, for the Planned Cost, within the planned Margins for cost, schedule, and technical performance.

One place to start to improve the probability that we're all on the same page is this reading list. This is not an exhaustive list, and it is ever growing. But it's a start. It's hoped this list is the basis of a shared understanding that while Agile is a near universal principle, there are practices that must be tailored to specific domains. And one's experience in one domain may or may not be applicable to other domains. 

Like it says in the Scrum Guide. 

Scrum (n): A framework within which people can address complex adaptive problems, while productively and creatively delivering products of the highest possible value.

And since Scrum is an agile software development framework, Scrum is a framework not a methodology. Scrum of Scrums, Agile At Scale, especially Agile at Scale inside EIA-748-C programs has much different needs than 5 people sitting at the same table with their customer with an emerging set of requirements where the needed capabilities are vague until they appear.

One of the classes every aspiring grad student has to take is research methods. This class teaches the PhD hopefuls (I didn't make the cut and got a consolation prize of a MS), all about doing research and preparing to be a real scientist. A topic in this class is literature search. This makes sure that your cleaver idea of a research topic, in case your advisor hasn't gotten around at actually talking to you, has already been taken, researched, and solved. This is one problem in the physics world - you need an original idea. Replicating old ideas doesn't get you very far.

Here's a start of a literature search on merging Agile at Scale with Earned Value Management. I haven't gotten to the European and Far East journals yet. 

Slicing Work Into Small Pieces Agile Software Development in the DOD Technical Performance Measures What Do We Mean When We Say "Agile Community?" Can Enterprise Agile Be Bottom Up? How To Measure Anything Business Rhythm Drives Process Empirical Data Used to Estimate Future Performance Related articles
Categories: Project Management

Setting up Jenkins to run headless Selenium tests in Docker containers

Agile Testing - Grig Gheorghiu - Sat, 02/06/2016 - 01:40
This is the third post in a series on running headless Selenium WebDriver tests. Here are the first two posts:
  1. Running Selenium WebDriver tests using Firefox headless mode on Ubuntu
  2. Running headless Selenium WebDriver tests in Docker containers
In this post I will show how to add the final piece to this workflow, namely how to fully automate the execution of Selenium-based WebDriver tests running Firefox in headless mode in Docker containers. I will use Jenkins for this example, but the same applies to other continuous integration systems.
1) Install docker-engine on the server running Jenkins (I covered this in my post #2 above)
2) Add the jenkins user to the docker group so that Jenkins can run the docker command-line tool in order to communicate with the docker daemon. Remember to restart Jenkins after doing this.
3) Go through the rest of the workflow in my post above ("Running headless Selenium WebDriver tests in Docker containers") and make sure you can run all the commands in that post from the command line of the server running Jenkins.
4) Create a directory structure for your Selenium WebDriver tests (mine are written in Python). 
I have a directory called selenium-docker which contains a directory called tests, under which I put all my Python WebDriver tests named sel_wd_*.py. I also  have a simple shell script I named run_selenium_tests.sh which does the following:
#!/bin/bash
TARGET=$1 # e.g. someotherdomain.example.com (if not specified, the default is somedomain.example.com)
for f in `ls tests/sel_wd_*.py`; do    echo Running $f against $TARGET    python $f $TARGETdone
My selenium-docker directory also contains the xvfb.init file I need for starting up Xvfb in the container, and finally it contains this Dockerfile:
FROM ubuntu:trusty
RUN echo "deb http://ppa.launchpad.net/mozillateam/firefox-next/ubuntu trusty main" > /etc/apt/sources.list.d//mozillateam-firefox-next-trusty.listRUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys CE49EC21RUN apt-get updateRUN apt-get install -y firefox xvfb python-pipRUN pip install seleniumRUN mkdir -p /root/selenium/tests
ADD tests /root/selenium/testsADD run_all_selenium_tests.sh /root/selenium
ADD xvfb.init /etc/init.d/xvfbRUN chmod +x /etc/init.d/xvfbRUN update-rc.d xvfb defaults
ENV TARGET=somedomain.example.com
CMD (service xvfb start; export DISPLAY=:10; cd /root/selenium; ./run_all_selenium_tests.sh $TARGET)
I explained what this Dockerfile achieves in the 2nd post referenced above. The ADD instructions will copy all the files in the tests directory to the directory called /root/selenium/tests, and will copy run_all_selenium_tests.sh to /root/selenium. The ENV variable TARGET represents the URL against which we want to run our Selenium tests. It is set by default to somedomain.example.com, and is used as the first argument when running run_all_selenium_tests.sh in the CMD instruction.
At this point, I checked in the selenium-docker directory and all files and directories under it into a Github repository I will call 'devops'.
5) Create a new Jenkins project (I usually create a New Item and copy it from an existing project).
I specified that the build is parameterized and I indicated a choice parameter called TARGET_HOST with a few host/domain names that I want to test. I also specified Git as the Source Code Management type, and I indicated the URL of the devops repository on Github. Most of the action of course happens in the Jenkins build step, which in my case is of type "Execute shell". Here it is:
#!/bin/bash
set +e
IMAGE_NAME=selenium-wd:v1
cd $WORKSPACE/selenium-docker
# build the image out of the Dockerfile in the current directory/usr/bin/docker build -t $IMAGE_NAME .
# run a container based on the imageCONTAINER_ID=`/usr/bin/docker run -d -e "TARGET=$TARGET_HOST" $IMAGE_NAME`
echo CONTAINER_ID=$CONTAINER_ID  # while the container is still running, sleep and check logs; repeat every 40 secwhile [ $? -eq 0 ];do  sleep 40  /usr/bin/docker logs $CONTAINER_ID  /usr/bin/docker ps | grep $IMAGE_NAMEdone
# docker logs sends errors to stderr so we need to save its output to a file first/usr/bin/docker logs $CONTAINER_ID > d.out 2>&1
# remove the container so they don't keep accumulatingdocker rm $CONTAINER_ID
# mark jenkins build as failed if log output contains FAILEDgrep "FAILED" d.out
if [[ $? -eq 0 ]]; then    rm d.out   exit 1else  rm d.out  exit 0fi
Some notes:
  • it is recommended that you specify #!/bin/bash as the 1st line of your script, to make sure that bash is the shell that is being used
  • use set +e if you want the Jenkins shell script to continue after hitting a non-zero return code (the default behavior is for the script to stop on the first line it encounters an error and for the build to be marked as failed; subsequent lines won't get executed, resulting in much pulling of hair)
  • the Jenkins script will build a new image every time it runs, so that we make sure we have updated Selenium scripts in place
  • when running the container via docker run, we specify -e "TARGET=$TARGET_HOST" as an extra command line argument. This will override the ENV variable named TARGET in the Dockerfile with the value received from the Jenkins multiple choice dropdown for TARGET_HOST
  • the main part of the shell script stays in a while loop that checks for the return code of "/usr/bin/docker ps | grep $IMAGE_NAME". This is so we wait for all the Selenium tests to finish, at which point docker ps will not show the container running anymore (you can still see the container by running docker ps -a)
  • once the tests finish, we save the stdout and stderr of the docker logs command for our container to a file (this is so we capture both stdout and stderr; at first I tried something like docker logs $CONTAINER_ID | grep FAILED but this was never successful, because it was grep-ing against stdout, and errors are sent to stderr)
  • we grep the file (d.out) for the string FAILED and if we find it, we exit with code 1, i.e. unsuccessful as far as Jenkins is concerned. If we don't find it, we exit successfully with code 0.


Android Studio 2.0 - Beta

Android Developers Blog - Fri, 02/05/2016 - 23:40

Posted by Jamal Eason, Product Manager, Android

Android Studio 2.0 is latest release of the official Android IDE focused on build performance and emulator speed to improve the app development experience. With brand new features like Instant Run which enables you to quickly edit and view code changes, or the new & faster Android emulator, Android Studio 2.0 is the upgrade you do not want to miss. In preparation for the final release, you can download Android Studio 2.0 Beta in the Beta release channel. Overall, the Android Studio 2.0 release has a host of new features which include:

  • *Updated for Beta* Instant Run - Enables a faster code edit & app deployment cycle.
  • *Updated for Beta* Android Emulator - Brand new emulator that is faster than most real devices, and includes a brand new user interface.
  • *Updated for Beta* Google App Indexing Integration & Testing - Adding App Indexing into your app helps you re-engage your users. In the first preview of Android Studio 2.0 you could add indexing code stubs into your code. With the beta release you can now test and validate your URL links in your app all within the IDE.
  • Fast ADB - Installing and pushing files is now up to 5x faster using Android Studio 2.0 with an updated Android Debug Bridge (ADB) offered in platform-tools 23.1.0.
  • GPU Profiler Preview - For graphics intensive applications, you can now visually step through your OpenGL ES code to optimize your app or game
  • Integration of IntelliJ 15 - Android Studio is based on the efficient coding platform of Intellij. Check out the new features from IntelliJ here.

Check out the latest installment of Android Studio Tool Time video below to watch the highlights of the features.



New Features in Android Studio 2.0 Beta
Instant Run

We first previewed Instant Run in November; this latest beta release introduces a new capability called Cold Swap

Instant Run in Android Studio 2.0 allows you to quickly make changes to your app code while your app is running on an Android device or Android Emulator. Instead of waiting for your entire app to rebuild and redeploy after each code change, Android Studio 2.0 will try to incrementally build and push only the incremental code or resource change. Depending on the code changes you make, you can see the results of your change in under a second. By simply updating your app to use the latest Gradle plugin ( 'com.android.tools.build:gradle:2.0.0-beta2’ ), you can take advantage of this time saving features with no other modifications to your code. If your project is setup correctly with Instant Run, you will see a lightning bolt next to your Run button on the toolbar:


Instant Run Button

Behind the scenes, Android Studio 2.0 instruments your code during the first compilation and deployment of your app to your device in order to determine where to swap out code and resources. The Instant Run features updates your app on a best-effort basis and automatically uses one of the following swap methods to update your app:

  • Hot Swap - When only method implementations (including constructors) are changed, the changes are hot swapped. Your application keeps running and the new implementation is used the next time the method is called.
  • Warm Swap - When app resources are changed, the changes are warm swapped. This is similar to a hot swap, except that the current Activity is restarted. You will notice a slight flicker on the screen as the Activity restarts.
  • *New for Beta* Cold Swap - This will quickly restart the whole application. Typically for structural code change, including changes to the class hierarchy, method signatures, static initializers, or fields. Cold Swap is available when you deploy to targets with API level 21 or above.

We made major changes to Instant Run since the first preview of Android Studio 2.0, and now the feature works with more code and resources cases. We will continue to add more code change cases to Instant Run in future releases of Android Studio. If you have any suggestions, please feel free to send us a feature request and learn more about Instant Run here.

App Indexing

Supporting app indexing is now even easier with Android Studio 2.0. App Indexing puts your app in front of users who use Google Search. It works by indexing the URL patterns you provide in your app manifest and using API calls from your app to make content within your app available to both existing and new users. Specifically, when you support URLs for your app content, your users can go directly to those links from Google Search results on their device.

  • Code Generation Introduced in Android Studio 2.0 Preview, you can right click on AndroidManifest.xml or Activity method (or go to Code → Generate…→ App Indexing API Code) to insert HTTP URL stub codes into your manifest and app code.

  • *New for Beta* URL Testing & Validation What is new in Android Studio 2.0 Beta is that you can now validate and check the results of your URLs with the built-in validation tool (Tools → Android → Google App Indexing Test). To learn more about app indexing, click here.

Insert App Indexing API Code into your app

App Indexing Testing


App Indexing Test Results

Android Emulator

*Updated for Beta* The new and faster Android emulator also includes fixes and small enhancements for this beta release. Notably, we updated the rotation controls on the emulator toolbar and added multi-touch support to help test apps that use pinch & zoom gestures. To use the multi-touch feature, hold down the Alt key on your keyboard and right-click your mouse to center the point of reference or click & drag the left mouse button to zoom.


Pinch & Zoom Gesture with Multi-Touch

What's Next

Android Studio 2.0 is a big release, and now is good time to check out the beta release to incorporate the new features into your workflow. The beta release is near stable release quality, and should be relatively bug free. But as with any beta release, bugs may still exist, so, if you do find an issue, let us know so we can work to fix it. If you’re already using Android Studio, you can check for updates on the Beta channel from the navigation menu (Help → Check for Update [Windows/Linux] , Android Studio → Check for Updates [OS X]). When you update to beta, you will get access to the new version of Android Studio and Android Emulator.

Connect with us, the Android Studio development team, on Google+.

Categories: Programming

Stuff The Internet Says On Scalability For February 5th, 2016


We have an early entry for the best vacation photo of the century. 

 

If you like this sort of Stuff then please consider offering your support on Patreon.
  • 1 billion: WhatsApp users; 3.5 billion: Facebook users in 2030; $3.5 billion: art sold online; $150 billion: China's budget for making chips; 37.5MB: DNA information in a single sperm; 

  • Quotable Quotes:
    • @jeffiel: "But seriously developers, trust us next time your needs temporarily overlap our strategic interests. And here's a t-shirt."
    • @feross: Modern websites are the epitome of inefficiency. Using giant multi-MB javascript files to do what static HTML could do in 1999.
    • Rob Joyce (NSA): We put the time in …to know [that network] better than the people who designed it and the people who are securing it,' he said. 'You know the technologies you intended to use in that network. We know the technologies that are actually in use in that network. Subtle difference. You'd be surprised about the things that are running on a network vs. the things that you think are supposed to be there.
    • @MikeIsaac: i just realized how awkward Facebook's f8 conference is gonna be this year
    • @Nick_Craver: Stats correction: Stack Overflow did 157,370,800,409 redis ops in the past 30 days, almost always under 2% CPU:
    • @BenedictEvans: The global SMS system does around 20bn messages a day. WhatsApp is now doing 42bn. With 57 engineers.
    • @jaygoldberg: WhatsApp has the benefit of running on top of the world's data networks which employ a few more engineers... 
    • @anildash: It’s odd that developers think Twitter is so hostile while Facebook shuts down stuff like Parse & FBML + cuts back the Instagram & FB APIs.
    • @asynchio:  I use to think CEP = stateful business rules engine + inference + stream processing. Has it changed?
    • @Marco_Rasp: "SOA is about reuse, MicroServices about time to market." @samnewman #microxchg
    • @pfhllnts: "I predict quantum containers where Docker exists both inside and outside a container." @marcoceppi #fosdem
    • @viktorklang: Awesome story: 295x speedup with Akka Streams on same HW compared to Rails :) 
    • krinchan: Yes. Because a currency almost completely controlled by Chinese miners who are strangling the network at 1MB blocks, causing transaction times in excess of three hours at peak and just introduced the ability to arbitrarily reverse those transactions during the lag is totally going to handle DraftKings and FanDuel.
    • @mpesce: 1/The Apple AX series SOCs are more than powerful enough to run a Hololens-type device very effectively.
    • Matthew Yglesias: Amazon's leadership, from CEO Jeff Bezos on down, are deliberately redeploying every dollar of revenue Amazon earns into making the company bigger and bigger.
    • German forest ranger finds that trees have social networks: trees operate less like individuals and more as communal beings. Working together in networks and sharing resources, they increase their resistance to threats
    • @ValaAfshar: 11 years ago some guy named Mark Zuckerberg talks about his new company. He is now 4th richest person in the world. 
    • Bernard Marr: In China, the government is rolling out a social credit score that aggregates not only a citizen’s financial worthiness, but also how patriotic he or she is, what they post on social media, and who they socialize with
    • @Carnage4Life: Facebook is valued at $326 billion and worth more than Exxon Mobil. Remember when people freaked out at $15B value? 
    • @Nick_Craver: High levels of efficiency at scale aren't one thing; it's a thousand things. Many we haven't really shared in detail...and we should.
    • 2BuellerBells: Things to reinvent: Event loops (done!) Unix (In progress!) Erlang (est. 5 years)
    • @LusciousPear: I'm consistently seeing GETs from @googlecloud storage 2-5x faster than S3. niiiice
    • Kevin Old: The future looks mighty scalable.
    • @BenedictEvans: All curation grows until it requires search. All search grows until it requires curation.
    • @Carnage4Life: Google has 7 services with 1B monthly active users; Gmail, Search, Chrome, Android, Maps, YouTube and Google Play 
    • @jmhodges: That's 1.3 million unique domains in a single day. Yesterday. Let's Encrypt is doing a thing.
    • @danielbryantuk: "60% percent of app users rate performance/response time ahead of features" @grabnerandi  #OOP2016 
    • @tdeekens: Sometimes Monoliths don’t get enough respect. They’re part of our revenue system allowing us to build Microservices. They gave us a business
    • Searching for the Algorithms Underlying Life: Valiant’s self-stated goal is to find “mathematical definitions of learning and evolution which can address all ways in which information can get into systems.” If successful, the resulting “theory of everything”...would literally fuse life science and computer science together.
    • @mountain_ghosts: 1995: the information superhighway will mean anyone can do anything from anywhere 2015: must be willing to relocate to San Francisco

  • Fingerprinting made burglars put on gloves. CCTV made kids pull their hoods up. Spying made honest people use encryption. Forensics: What Bugs, Burns, Prints, DNA and More Tell Us About Crime.

  • So that's what bandwidth means. ucaetano: The bandwidth doesn't depend on the frequency you're occupying, but on the amount of spectrum available: you "usually" get in the order of 1 bps for every Hz of spectrum available for mobile: a 20Mz chunk of spectrum will give you ~20Mbps, no matter if it is 700MHz or 5 GHz. Higher frequencies have awful penetration and range, that's why today you define who wins in the mobile game by the amount of 700MHz and 800MHz spectrum they own. In other words, lower frequency spectrum is (within certain limits) always better.

  • Even spies have limits. Optic Nerve: millions of Yahoo webcam images intercepted by GCHQ. A British surveillance agency suffered the indignity of only saving images every five minutes from user feeds to reduce server load. My kingdom for a cloud! Why? They needed data to train their face recognition algorithms. That's what happens if you aren't Google.

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