555 research outputs found
Bright Spots Leadership in the Pacific Northwest
The operating environment for nonprofit cultural organizations today is daunting. Demographic shifts, changing participation patterns, evolving technology, increased competition for consumer attention, rising costs of doing business, shifts in the philanthropic sector and public funding, and the lingering recession form a stew of change and uncertainty. Every cultural organization is experiencing a combination of these shifts, each in its own way. Yet, while some organizations are struggling in this changing context, others are managing to stay healthy and dynamic while operating under the same conditions as their peers. These groups are observable exceptions, recognized by their peers as achieving success outside the norm in their artistic program, their engagement of community, and/or their financial stability. These are the "bright spots" of the cultural sector.Who are they? What are they doing differently? What can we learn by studying their behavior?To explore these questions, the Paul G. Allen Family Foundation asked Helicon Collaborative to conduct a study of cultural groups in the Pacific Northwest. The project had two goals: 1) to identify "bright spots," defined as cultural organizations that are successfully adapting to their changing circumstances without exceptional resources, and 2) to see if these organizations share characteristics or strategies that can be replicated by others
libcloudph++ 0.2: single-moment bulk, double-moment bulk, and particle-based warm-rain microphysics library in C++
This paper introduces a library of algorithms for representing cloud
microphysics in numerical models. The library is written in C++, hence the name
libcloudph++. In the current release, the library covers three warm-rain
schemes: the single- and double-moment bulk schemes, and the particle-based
scheme with Monte-Carlo coalescence. The three schemes are intended for
modelling frameworks of different dimensionality and complexity ranging from
parcel models to multi-dimensional cloud-resolving (e.g. large-eddy)
simulations. A two-dimensional prescribed-flow framework is used in example
simulations presented in the paper with the aim of highlighting the library
features. The libcloudph++ and all its mandatory dependencies are free and
open-source software. The Boost.units library is used for zero-overhead
dimensional analysis of the code at compile time. The particle-based scheme is
implemented using the Thrust library that allows to leverage the power of
graphics processing units (GPU), retaining the possibility to compile the
unchanged code for execution on single or multiple standard processors (CPUs).
The paper includes complete description of the programming interface (API) of
the library and a performance analysis including comparison of GPU and CPU
setups.Comment: The library description has been updated to the new library API (i.e.
v0.1 -> v0.2 update). The key difference is that the model state variables
are now mixing ratios as opposed to densities. The particle-based scheme was
supplemented with the "particle recycling" process. Numerous editorial
corrections were mad
Visualization of Practices and Metrics (Workpackage 1.2)
Measuring applications is a challenge and one of the goal of the Squale project is to propose a sound quality model. Now presenting the results of such analysis is also a challenge since it is complex to output and present to the user for the following rea- sons: first a lot of data should be presented and at different audience. Second displaying information is one aspect another one is navigating the information. Finally it is im- portant not to overwhelm the users with too much visualizations. This workpackage presents a state of the art in terms of software visualization approaches that are specif- ically designed to display metrics. In addition it sets up the context for the application of such visualization to practices
Automated Tool for Software Requirements Inspection
The software inspection process is a very cost effective method of identifying
defects in documents produced during the software life cycle, leading to higher quality
software with lower field failures. Manual inspections are labor intensive and dependent on
human factors (e.g., preparation, moderation, and cooperation among development and
quality assurance teams). An automated software inspection tool replaces a labor intensive
manual approach of performing the inspection process. An automated inspection tool will
offer greater efficiencies than any techniques involving manual inspections. Automation
allows stakeholders (e.g., authors, inspectors) to closely work in coordination using the
tool. Authors can host documents, view comments posted by inspectors, assign users and
delete them. Inspectors can participate in the inspection process by validating against a set
of guidelines and detect faults in a specific frame of time using different fault and error
based inspection techniques. It is human to err, and as a result some of the faults may be
overlooked. Hence, provisions are made for iterative inspection cycles to maximize the
number of defects found and minimize the number of overlooked ones
Package mountaineer tourists holidaying in the French Alps: An evaluation of key influences encouraging their participation
This study investigates the key influences that encourage mountaineer tourists, classified as a type of
adventure tourist, to participate in package mountaineering holidays. There is limited understanding of
why tourists take package adventure holidays, yet the demand for such holidays has grown dramatically
in recent years. The author conducted in-depth interviews with mountaineer tourists either during or at
the end of their package mountaineering holiday in the Chamonix region of the French Alps. Interview
findings provide an insight into package mountaineer tourists. Firstly, mountaineering was an important
part of respondents’ lifestyles. Secondly, contrary to previous research on experienced mountaineers,
respondents did not consider risk as an important motive and they did not view themselves as risk
takers. Thirdly, skills development and experience were key motives encouraging package mountaineering
holiday participation. Fourthly, a major concern for respondents was to have a safe mountaineering
experience in which the mountaineering organisation and the guide played a key role
The busy coder's guide to Android development
380 p. ; il. , Indice.Libro ElectrĂłnicoIf you are interested in programming for Android, you will need at least basic understanding of how to program in Java. Android programming is done using Java syntax, plus a class library that resembles a subset of the Java SE library (plus Android-specific extensions). If you have not programmed in Java before, you probably should quick learn how that works before attempting to dive into programming for Android.
The book does not cover in any detail how to download or install the Android development tools, either the Eclipse IDE flavor or the standalone flavor. The Android Web site covers this quite nicely. The material in the book should be relevant whether you use the IDE or not. You should download, install, and test out the Android development tools from the Android Web site before trying any of the examples listed in this book.Welcome to the Warescription!xiii
Prefacexv
Welcome to the Book!xv
Prerequisitesxv
Warescriptionxvi
Book Bug Bountyxvii
Source Code Licensexviii
Creative Commons and the Four-to-Free (42F) Guaranteexviii
The Big Picture1
What Androids Are Made Of3
Activities3
Content Providers4
Intents4
Services4
Stuff At Your Disposal5
Storage5
Network5
Multimedia5
GPS5
Phone Services6
Project Structure7
Root Contents7
The Sweat Off Your Brow8
iii
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
And Now, The Rest of the Story8
What You Get Out Of It9
Inside the Manifest11
In The Beginning, There Was the Root, And It Was Good11
Permissions, Instrumentations, and Applications (Oh, My!)12
Your Application Does Something, Right?13
Creating a Skeleton Application17
Begin at the Beginning17
The Activity18
Dissecting the Activity19
Building and Running the Activity21
Using XML-Based Layouts23
What Is an XML-Based Layout?23
Why Use XML-Based Layouts?24
OK, So What Does It Look Like?25
What's With the @ Signs?26
And We Attach These to the JavaHow?26
The Rest of the Story27
Employing Basic Widgets29
Assigning Labels29
Button, Button, Who's Got the Button?30
Fleeting Images31
Fields of Green Or Other Colors31
Just Another Box to Check34
Turn the Radio Up37
It's Quite a View39
Useful Properties39
Useful Methods39
Working with Containers41
Thinking Linearly42
Concepts and Properties42
Example45
All Things Are Relative50
iv
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Concepts and Properties50
Example53
Tabula Rasa56
Concepts and Properties56
Example59
Scrollwork60
Using Selection Widgets65
Adapting to the Circumstances65
Using ArrayAdapter66
Other Key Adapters67
Lists of Naughty and Nice68
Spin Control70
Grid Your Lions (Or Something Like That)74
Fields: Now With 35% Less Typing!78
Galleries, Give Or Take The Art82
Employing Fancy Widgets and Containers83
Pick and Choose83
Time Keeps Flowing Like a River88
Making Progress89
Putting It On My Tab90
The Pieces91
The Idiosyncrasies91
Wiring It Together93
Other Containers of Note96
Applying Menus97
Flavors of Menu97
Menus of Options98
Menus in Context100
Taking a Peek102
Embedding the WebKit Browser107
A Browser, Writ Small107
Loading It Up109
Navigating the Waters111
v
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Entertaining the Client111
Settings, Preferences, and Options (Oh, My!)114
Showing Pop-Up Messages117
Raising Toasts117
Alert! Alert!118
Checking Them Out119
Dealing with Threads123
Getting Through the Handlers123
Messages124
Runnables127
Running In Place127
Utilities (And I Don't Mean Water Works)128
And Now, The Caveats128
Handling Activity Lifecycle Events131
Schroedinger's Activity131
Life, Death, and Your Activity132
onCreate() and onCompleteThaw()132
onStart(), onRestart(), and onResume()133
onPause(), onFreeze(), onStop(), and onDestroy()134
Using Preferences137
Getting What You Want137
Stating Your Preference138
A Preference For Action138
Accessing Files143
You And The Horse You Rode In On143
Readin' 'n Writin'147
Working with Resources151
The Resource Lineup151
String Theory152
Plain Strings152
String Formats153
Styled Text153
Styled Formats154
vi
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Got the Picture?158
XML: The Resource Way160
Miscellaneous Values163
Dimensions163
Colors164
Arrays165
Different Strokes for Different Folks166
Managing and Accessing Local Databases171
A Quick SQLite Primer172
Start at the Beginning173
Setting the Table174
Makin' Data174
What Goes Around, Comes Around176
Raw Queries176
Regular Queries177
Building with Builders177
Using Cursors179
Change for the Sake of Change179
Making Your Own Cursors180
Data, Data, Everywhere180
Leveraging Java Libraries183
The Outer Limits183
Ants and Jars184
Communicating via the Internet187
REST and Relaxation187
HTTP Operations via Apache Commons188
Parsing Responses190
Stuff To Consider192
Email over Java193
Creating Intent Filters199
What's Your Intent?200
Pieces of Intents200
Stock Options201
vii
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Intent Routing202
Stating Your Intent(ions)203
Narrow Receivers205
Launching Activities and Sub-Activities207
Peers and Subs208
Start 'Em Up208
Make an Intent209
Make the Call209
Finding Available Actions via Introspection215
Pick 'Em216
Adaptable Adapters220
Would You Like to See the Menu?223
Asking Around225
Using a Content Provider229
Pieces of Me229
Getting a Handle230
Makin' Queries231
Adapting to the Circumstances233
Doing It By Hand235
Position235
Getting Properties236
Setting Properties237
Give and Take238
Beware of the BLOB!239
Building a Content Provider241
First, Some Dissection241
Next, Some Typing242
Step #1: Create a Provider Class243
ContentProvider243
DatabaseContentProvider252
Step #2: Supply a Uri252
Step #3: Declare the Properties252
Step #4: Update the Manifest253
viii
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Notify-On-Change Support254
Requesting and Requiring Permissions257
Mother, May I?258
Halt! Who Goes There?259
Enforcing Permissions via the Manifest260
Enforcing Permissions Elsewhere261
May I See Your Documents?262
Creating a Service263
Getting Buzzed264
Service with Class264
When IPC Attacks!266
Write the AIDL267
Implement the Interface268
Manifest Destiny270
Where's the Remote?271
Invoking a Service273
Bound for Success274
Request for Service276
Prometheus Unbound276
Manual Transmission276
Alerting Users Via Notifications279
Types of Pestering279
Hardware Notifications280
Icons281
Letting Your Presence Be Felt281
Accessing Location-Based Services287
Location Providers: They Know Where You're Hiding288
Finding Yourself288
On the Move292
Are We There Yet? Are We There Yet? Are We There Yet?292
TestingTesting296
Mapping with MapView and MapActivity299
The Bare Bones299
ix
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Exercising Your Control301
Zoom301
Center302
Reticle303
Traffic and Terrain303
Follow You, Follow Me305
Layers Upon Layers307
Overlay Classes308
Drawing the Overlay308
Handling Screen Taps310
Playing Media313
Get Your Media On314
Making Noise315
Moving Pictures321
Handling Telephone Calls325
No, No, No – Not That IPhone326
What's Our Status?326
You Make the Call!326
Searching with SearchManager333
Hunting Season333
Search Yourself335
Craft the Search Activity336
Update the Manifest340
Try It Out342
The TourIt Sample Application347
Installing TourIt347
Demo Location Provider347
SD Card Image with Sample Tour348
Running TourIt349
Main Activity350
Configuration Activity352
Cue Sheet Activity354
Map Activity355
x
Subscribe to updates at http://commonswarecom Special Creative Commons BY-NC-SA 30 License Edition
Tour Update Activity357
Help Activity358
TourIt's Manifest359
TourIt's Content360
Data Storage361
Content Provider361
Model Classes361
TourIt's Activities362
TourListActivity362
TourViewActivity363
TourMapActivity367
TourEditActivity367
HelpActivity367
ConfigActivity36
Visualising The Complex Features Of Source Code
Software development is a complex undertaking composed of several activities that include reading, writing, and modifying source code. Indeed, previous studies have shown that the majority of the effort invested in software development is dedicated to understanding code. This includes understanding the static structure, dynamic behaviour, and evolution of the code. Given these particular characteristics, as well as the high complexity of source code, it is reasonable to consider how visualisation can facilitate source code understanding. This work proposes to extend existing software development tools with visualisations that can be used to encode the various complex features within a source code document. Further, this work establishes a design space which includes a series of visualisations that are meant to complement existing textual views of source code, as found in source code editors. Several prototype visualisations are presented in this work which utilise various visualisation techniques, such as tree visualisations techniques and visualisation techniques based on the code-map metaphor. This work also presents several experiments, where the results of these experiments indicate that combining existing software development tools with visualisations can have a positive effect on source code understanding. Additionally, the result of the experiments show that the less a visualisation is abstracted from the original textural representation of a source code document, in terms of line, token, ordering, and character information, the more likely it is that viewers can link the visualisation to the code and back
- …