[Testing] Google Test Automation Conference & OLPC

[Samuel Greenfeld]

Last week I was at the Google Test Automation Conference (GTAC), an annual
event held this year in Mountain View, California, USA.

The videos and source material from this conference will be posted to
http://www.gtac.biz/talks , with most of the videos already online.  Past
years' conferences may also be found on YouTube.

There were a variety of talks this year on web and browser automation, as
well as on other things.  But from an OLPC perspective I just wanted to
touch on several talks that I personally considered relevant, sorted by
their appearance in the conference as well as on the aforementioned web
page:



   - "Test Is Dead" (Alberto Savoia):  The opening keynote focused on how
   companies in many fields are getting rid of software testers and holding
   developers more accountable for their code.  The focus now is "making the
   right it, not making it right" to verify that concepts are viable to a wide
   audience as quickly as possible.

   The longer a company spends on a development path, the harder it is to
   change it later.  Rapidly releasing new versions can help find "idea bugs"
   faster while leaving "code bugs" users tolerate.

   From an OLPC/Sugar perspective, we should try and do this with user
   interface changes, etc., including getting feedback from deployments as
   well other end-users.  But it may not be possible for us to completely
   eliminate my job, as many deployments only update their XO software once
   per year or so.

   This may be important for verifying the Nell[*] proof-of-concept as
   something which schools/foundations/countries/governments/etc. will want to
   pay for as opposed to something which just sounds cool to do.

   [*] http://cananian.livejournal.com/65077.html


   - Developing and Testing WebGL (Roy Williams): This may also be relevant
   to Nell.  WebGL (a 3D programming language) is usually rendered directly by
   the graphics card.  This leaves the WebGL canvas appearing more or less as
   a "black box" inside the browser.  It is therefore somewhat hard to
   automate WebGL testing, as there is no guarantee that you can see what is
   inside of it.

   A Model/View/Controller programming style is recommended to make
   debugging and testing of WebGL applications easier.  Google also released a
   tool to help do WebGL testing at this event (one of many tools whose source
   code was released at this conference), but I have not had a chance to look
   into its abilities.


   - BidiChecker: Automated Bidi Testing of Web Applications (Yana Margolin
   & Jason Elbaum):  Not every language is written left-to-right.  Arabic,
   Hebrew, and some others are written right-to-left.

   But within right-to-left languages, some items (numbers, etc.) may still
   be written left-to-right.  It may also be desirable to mix right-to-left
   and left-to-right languages within the same interface.

   When testing translations, it is not just important to make sure that
   the insertion order of parameters is correct for each translation within a
   single language, but also the text direction of each translated string &
   its parameters.   Checks also need to be done on combinations of
   translations as well as the entire layout of an interface as a whole.

   While I believe GTK+ tries to automate much of this for us, there is no
   guarantee that its default approach will be correct.  We therefore need
   native and/or well-taught speakers to tell us if something looks incorrect.


   - How to Hit a Moving Target in the Cloud (Vishal Chowdhary):  This talk
   focused on verifying machine-based language translation, where the
   "correct" result output for a translated sentence could be one of many
   results.

   One therefore has to look at pieces of the translation puzzle to figure
   out if the output makes sense without re-writing your own translation
   engine.  Having people test and provide feedback also is useful.  This
   results in gray answers for test results, but can give you an idea of if
   something is terribly incorrect.

   This also may be relevant to Nell, where the user's progress may control
   how the environment changes.


   - How Hackers See Bugs (Hugh Thompson):  The first day closing keynote
   does not talk about "bugs" in the traditional software sense, but rather
   covers a variety of issues.  It looks at how trust relationships can be
   exploited, and how security measures and public data from past years can be
   exploited to wreck havoc in the present.

   This talk also contains a few examples of why it important to present an
   interface that users can intuitively understand how to use, especially when
   they are not given clear instructions on how to use it.  Such an approach
   is generally relevant to Sugar.


   - Latest in Google Test Tools (Ibrahim El-Far & Jason Arbon):  Mostly
   interesting from a manual test perspective, as Google has taken out a lot
   of the side tasks related to manual testing.  I think it may be worthwhile
   to write a Sugar activity which does similar.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.laptop.org/pipermail/testing/attachments/20111104/1af2aaa3/attachment.html>