# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 23 def initialize(klass, table) @klass, @table = klass, table @implicit_readonly = nil @loaded = false @default_scoped = false SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)} (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])} @extensions = [] @create_with_value = {} end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 426 def ==(other) case other when Relation other.to_sql == to_sql when Array to_a == other end end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 153 def any? if block_given? to_a.any? { |*block_args| yield(*block_args) } else !empty? end end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 89 def create(*args, &block) scoping { @klass.create(*args, &block) } end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 93 def create!(*args, &block) scoping { @klass.create!(*args, &block) } end
Deletes the row with a primary key matching the id
argument,
using a SQL DELETE
statement, and returns the number of rows
deleted. Active Record objects are not instantiated, so the object’s
callbacks are not executed, including any :dependent
association options or Observer methods.
You can delete multiple rows at once by passing an Array of id
s.
Note: Although it is often much faster than the alternative,
#destroy
, skipping callbacks might bypass business logic in
your application that ensures referential integrity or performs other
essential jobs.
# Delete a single row Todo.delete(1) # Delete multiple rows Todo.delete([2,3,4])
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 378 def delete(id_or_array) IdentityMap.remove_by_id(self.symbolized_base_class, id_or_array) if IdentityMap.enabled? where(primary_key => id_or_array).delete_all end
Deletes the records matching conditions
without instantiating
the records first, and hence not calling the destroy
method
nor invoking callbacks. This is a single SQL DELETE statement that goes
straight to the database, much more efficient than
destroy_all
. Be careful with relations though, in particular
:dependent
rules defined on associations are not honored.
Returns the number of rows affected.
conditions
- Conditions are specified the same way as with
find
method.
Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')") Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else']) Post.where(:person_id => 5).where(:category => ['Something', 'Else']).delete_all
Both calls delete the affected posts all at once with a single DELETE
statement. If you need to destroy dependent associations or call your
before_*
or after_destroy
callbacks, use the
destroy_all
method instead.
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 345 def delete_all(conditions = nil) IdentityMap.repository[symbolized_base_class] = {} if IdentityMap.enabled? if conditions where(conditions).delete_all else statement = arel.compile_delete affected = @klass.connection.delete(statement, 'SQL', bind_values) reset affected end end
Destroy an object (or multiple objects) that has the given id, the object is instantiated first, therefore all callbacks and filters are fired off before the object is deleted. This method is less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
This essentially finds the object (or multiple objects) with the given id, creates a new object from the attributes, and then calls destroy on it.
# Destroy a single object Todo.destroy(1) # Destroy multiple objects todos = [1,2,3] Todo.destroy(todos)
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 318 def destroy(id) if id.is_a?(Array) id.map { |one_id| destroy(one_id) } else find(id).destroy end end
Destroys the records matching conditions
by instantiating each
record and calling its destroy
method. Each object’s callbacks
are executed (including :dependent
association options and
before_destroy
/after_destroy
Observer methods). Returns the collection of
objects that were destroyed; each will be frozen, to reflect that no
changes should be made (since they can’t be persisted).
Note: Instantiation, callback execution, and deletion of each record can be
time consuming when you’re removing many records at once. It generates at
least one SQL DELETE
query per record (or possibly more, to
enforce your callbacks). If you want to delete many rows quickly, without
concern for their associations or callbacks, use delete_all
instead.
conditions
- A string, array, or hash that specifies which
records to destroy. If omitted, all records are destroyed. See the
Conditions section in the introduction to ActiveRecord::Base for more information.
Person.destroy_all("last_login < '2004-04-04'") Person.destroy_all(:status => "inactive") Person.where(:age => 0..18).destroy_all
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 291 def destroy_all(conditions = nil) if conditions where(conditions).destroy_all else to_a.each {|object| object.destroy }.tap { reset } end end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 412 def eager_loading? @should_eager_load ||= @eager_load_values.any? || @includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?) end
Returns true if there are no records.
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 146 def empty? return @records.empty? if loaded? c = count c.respond_to?(:zero?) ? c.zero? : c.empty? end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 83 def initialize_copy(other) reset end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 36 def insert(values) primary_key_value = nil if primary_key && Hash === values primary_key_value = values[values.keys.find { |k| k.name == primary_key }] if !primary_key_value && connection.prefetch_primary_key?(klass.table_name) primary_key_value = connection.next_sequence_value(klass.sequence_name) values[klass.arel_table[klass.primary_key]] = primary_key_value end end im = arel.create_insert im.into @table conn = @klass.connection substitutes = values.sort_by { |arel_attr,_| arel_attr.name } binds = substitutes.map do |arel_attr, value|<EMAIL_ADDRESS>value] end substitutes.each_with_index do |tuple, i| tuple[1] = conn.substitute_at(binds[i][0], i) end if values.empty? # empty insert im.values = Arel.sql(connection.empty_insert_statement_value) else im.insert substitutes end conn.insert( im, 'SQL', primary_key, primary_key_value, nil, binds) end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 435 def inspect to_a.inspect end
Joins that are also marked for preloading. In which case we should just eager load them. Note that this is a naive implementation because we could have strings and symbols which represent the same association, but that aren’t matched by this. Also, we could have nested hashes which partially match, e.g. { :a => :b } & { :a => [:b, :c] }
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 422 def joined_includes_values @includes_values & @joins_values end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 161 def many? if block_given? to_a.many? { |*block_args| yield(*block_args) } else @limit_value ? to_a.many? : size > 1 end end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 79 def new(*args, &block) scoping { @klass.new(*args, &block) } end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 383 def reload reset to_a # force reload self end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 389 def reset @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil @should_eager_load = @join_dependency = nil @records = [] self end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 97 def respond_to?(method, include_private = false) arel.respond_to?(method, include_private) || Array.method_defined?(method) || @klass.respond_to?(method, include_private) || super end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 408 def scope_for_create @scope_for_create ||= where_values_hash.merge(create_with_value) end
Scope all queries to the current scope.
Comment.where(:post_id => 1).scoping do Comment.first # SELECT * FROM comments WHERE post_id = 1 end
Please check unscoped if you want to remove all previous scopes (including the default_scope) during the execution of a block.
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 179 def scoping @klass.send(:with_scope, self, :overwrite) { yield } end
Returns size of the records.
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 141 def size loaded? ? @records.length : count end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 104 def to_a return @records if loaded? default_scoped = with_default_scope if default_scoped.equal?(self) @records = if @readonly_value.nil? &&<EMAIL_ADDRESS>eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values) else IdentityMap.without do eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values) end end preload = @preload_values preload += @includes_values unless eager_loading? preload.each do |associations| ActiveRecord::Associations::Preloader.new(@records, associations).run end # @readonly_value is true only if set explicitly. @implicit_readonly is true if there # are JOINS and no explicit SELECT. readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value @records.each { |record| record.readonly! } if readonly else @records = default_scoped.to_a end @loaded = true @records end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 396 def to_sql @to_sql ||= klass.connection.to_sql(arel) end
Updates an object (or multiple objects) and saves it to the database, if validations pass. The resulting object is returned whether the object was saved successfully to the database or not.
id
- This should be the id or an array of ids to be updated.
attributes
- This should be a hash of attributes or an array
of hashes.
# Updates one record Person.update(15, :user_name => 'Samuel', :group => 'expert') # Updates multiple records people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } } Person.update(people.keys, people.values)
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 253 def update(id, attributes) if id.is_a?(Array) idx = -1 id.collect { |one_id| idx += 1; update(one_id, attributes[idx]) } else object = find(id) object.update_attributes(attributes) object end end
Updates all records with details given if they match a set of conditions supplied, limits and order can also be supplied. This method constructs a single SQL UPDATE statement and sends it straight to the database. It does not instantiate the involved models and it does not trigger Active Record callbacks or validations.
updates
- A string, array, or hash representing the SET part
of an SQL statement.
conditions
- A string, array, or hash representing the WHERE
part of an SQL statement. See conditions in the intro.
options
- Additional options are :limit
and
:order
, see the examples for usage.
# Update all customers with the given attributes Customer.update_all :wants_email => true # Update all books with 'Rails' in their title Book.update_all "author = 'David'", "title LIKE '%Rails%'" # Update all avatars migrated more than a week ago Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago] # Update all books that match conditions, but limit it to 5 ordered by date Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5 # Conditions from the current relation also works Book.where('title LIKE ?', '%Rails%').update_all(:author => 'David') # The same idea applies to limit and order Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(:author => 'David')
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 214 def update_all(updates, conditions = nil, options = {}) IdentityMap.repository[symbolized_base_class].clear if IdentityMap.enabled? if conditions || options.present? where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates) else stmt = Arel::UpdateManager.new(arel.engine) stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates)) stmt.table(table) stmt.key = table[primary_key] if joins_values.any? @klass.connection.join_to_update(stmt, arel) else stmt.take(arel.limit) stmt.order(*arel.orders) stmt.wheres = arel.constraints end @klass.connection.update stmt, 'SQL', bind_values end end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 400 def where_values_hash equalities = with_default_scope.where_values.grep(Arel::Nodes::Equality).find_all { |node| node.left.relation.name == table_name } Hash[equalities.map { |where| [where.left.name, where.right] }] end
# File c:/Ruby192/lib/ruby/gems/1.9.1/gems/activerecord-3.1.1/lib/active_record/relation.rb, line 451 def method_missing(method, *args, &block) if Array.method_defined?(method) to_a.send(method, *args, &block) elsif @klass.respond_to?(method) scoping { @klass.send(method, *args, &block) } elsif arel.respond_to?(method) arel.send(method, *args, &block) else super end end


|
|||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--ResourceManager.ResourceType
ResourceType: ResourceType reads and holds all the Resources of a single type (e.g. 'ICON', 'MENU'). It allows both individual Hashtable access and en masse Array access to the Resources. Public accessor methods are provided to access additional Type data such as the ID of the type and the number of Resources
| Constructor Summary | |
ResourceType()
|
| Method Summary | |
boolean |
contains(short idtocheck)
A convenience method allowing a test with a primitive short key in addition to the Short Object method |
boolean |
contains(java.lang.Short idtocheck)
Test whether a Resource of the given ID exists or not |
java.lang.String |
getID()
Returns the Type Code of this ResourceType, e.g. |
Resource[] |
getResArray()
Returns all the Resources of this ResourceType in a standard Array. |
Resource |
getResource(short idtoget)
A convenience method allowing access with a primitive short key in addition to the Short Object method |
Resource |
getResource(java.lang.Short idtoget)
Returns the single Resource keyed to the given ID. |
java.util.Enumeration |
getResourceIDs()
Returns an Enumeration of all the ID keys of the type to enable iterative Hashtable access to all the Resources of this type |
void |
print(java.io.PrintStream ps)
Dumps the ResourceType information (not including data) to a Stream |
void |
printAll(java.io.PrintStream ps)
Dumps the ResourceType information (not including data) to a Stream as well as the info of all the Resources it holds |
short |
size()
Returns the number of Items of this ResourceType |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
public ResourceType()
| Method Detail |
public void print(java.io.PrintStream ps)
ps
- the PrintStream to print the infopublic void printAll(java.io.PrintStream ps)
ps
- the PrintStream to print the infopublic short size()
public java.lang.String getID()
public Resource[] getResArray()
public Resource getResource(java.lang.Short idtoget)
idtoget
- the ID Key of the desired Resourcepublic Resource getResource(short idtoget)
idtoget
- the ID Key of the desired Resourcepublic boolean contains(java.lang.Short idtocheck)
idtocheck
- the Resource ID in questionpublic boolean contains(short idtocheck)
idtocheck
- the Resource ID in questionpublic java.util.Enumeration getResourceIDs()
|
|||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{% extends "base.html" %} {% block body %}
This website uses data available from the GitHub API. As such, only data for publicly viewable repositories can be collected.
Determination of a developer's location is done using the free-form data that they entered into their GitHub profile. For example, if the search is on "Victoria BC, Canada" but the developer didn't include the word Victoria (case insensitive) in their location, specifying for instance Saanich which is part of Victoria, then that developer's location will not match the query.


Automating container deployment is an important step into making your infrastructure easier to manage and scale. Administrators should be moving away from nursing their systems into higher level thinking where you design once and then automate changes on top of that system.
Below is a useful starting point for a Gitlab CI skeleton for building and pushing Docker containers into Amazon’s Elastic Container Service.
Skeleton .gitlab-ci.yml
variables:
IMAGE_NAME: "amazing-image"
CLUSTER_ARN: "ARN of ECS cluster"
SERVICE_ARN: "ARN of ECS service"
TASK_DEFINITION: "Task definition name in the service"
ECR_ADDRESS: "Container registry address"
ECS_REGION: "ECS region"
stages:
- build
build_job:
stage: build
artifacts:
paths:
- task-definition-${CI_COMMIT_SHA}.json
expire_in: 52 week
script:
- docker build -t "${IMAGE_NAME}" .
- eval $(aws ecr get-login --no-include-email --region "${ECS_REGION}")
- docker tag "${IMAGE_NAME}:latest" "${ECR_ADDRESS}:${CI_COMMIT_SHA}"
- docker push "${ECR_ADDRESS}:${CI_COMMIT_SHA}"
- sed -e "s;%BUILD_VERSION%;${CI_COMMIT_SHA};g" task-definition-base.json > task-definition-${CI_COMMIT_SHA}.json
- aws ecs register-task-definition --family "${TASK_DEFINITION}" --cli-input-json "file://task-definition-${CI_COMMIT_SHA}.json"
- aws ecs update-service --cluster "${CLUSTER_ARN}" --service "${SERVICE_ARN}" --task-definition "${TASK_DEFINITION}"
Operational Breakdown
- Build the image.
- Log into ECR.
- Tag the latest build we have produced with the ECR address and the commit hash.
- Create a new task defintion file locally based off the “base” version in the repository. The new task definition is locked to the version of the docker image produced by replacing the
%BUILD_VERSION%
parameter with the commit hash. - Register the new task definition with ECR.
- Tell the service to use the latest task definition available (by not specifying a revision with the
--task-definition
switch) which will be the new one registered in the previous step.
A base task definition is required, a oneliner to generate this based on an existing task defintion:
aws ecs describe-task-definition --task-definition <TASK_DEFINITION_NAME> | jq $({containerDefinitions: .taskDefinition.containerDefinitions, volumes: .taskDefinition.volumes}) | jq $(.containerDefinitions[0].image=)\"<ECR_ADDRESS>:%BUILD_VERSION%\" > task-definition-base.json
The <TASK_DEFINITION_NAME>
and <ECR_ADDRESS>
should be replaced with appropriate values to match your setup and the %BUILD_VERSION%
placeholder should be
left in the base file as build step 4 will replace this with the commit hash.
Docker and CI/CD Quirks
As of writing, Docker 17.06.0 doesn’t gracefully cleanup stale images. This will cause your CI server’s disk to fill up pretty quickly. A good tool to cleanup old containers is docker-gc.
Given your CI server should be pushing the images to a registry somewhere, there is usually no point keeping old images around. Therefore running docker-gc in an hourly CRON job as shown: MINIMUM_IMAGES_TO_SAVE=1 FORCE_IMAGE_REMOVAL=1 /usr/sbin/docker-gc
should help alleviate maintenance.
Further Enhancements/Considerations
- The skeleton has no concept of production/testing environments.
- ECR has a limit of 1000 images and needs to be cleaned up periodically.
Useful Sources
comments powered by Disqus


Pope Francis rides in carbon-free popemobile in Japan
by APPope Francis rode in a carbon-free popemobile at his Mass in Nagasaki, an appropriate choice in line with his environmental concerns.
Organisers say Francis used a Toyota hydrogen-powered Mirai, customised with a stand and handrails. He will use a similar model while in Tokyo.
The pope held a big Mass at a Nagasaki city baseball stadium. Earlier Sunday, he demanded world leaders renounce atomic weapons and the Cold War-era doctrine of deterrence and paid respects at a memorial for the 26 martyrs.
Environmental protection is one of Francis' key agenda items and is also part of the theme of his Japan visit.


ASAC
Home
About
Contact
Article author:
Article Title:
Subject:
Coding
3D printing
Cyber security
AI
date:


Red Side
Blue Side
Choose Color
Eraser
Clear
Warning!
Indicates a warning that might need attention.


--- layout: default title: Resources permalink: /resources redirect_from: - /chorus/resources ---
Here's some links to useful resources for singing in general and for our repertoire.


Caches
1 Map squares in the middle of the sea are unreachable by normal players, making it impossible to obtain the keys for their loc groups. However, the loc groups for these map squares are empty. As XTEA does not hide the length of the compressed data, this service infers which encrypted loc groups are empty and includes them in the number of valid keys, regardless of whether the key is known or not. After downloading a cache from this service, a cache editor may be used to replace the empty encrypted loc groups with unencrypted replacements.
2 Sizes are estimated based on the total
compressed length of all groups in the cache. The native
.dat2
/.idx
format has some overhead
above this, but the .zip
file generated by the
archiving service will reduce the overhead, so the estimated
size will roughly match the size of the .zip
file.


Kriegspiel (German for "War Game") is a chess variant of imperfect information. The premise is that, like war, you can see your own position, but not that of your opponent. You follow the rules of normal chess, and some information is given to you, but otherwise you must deduce where your opponents pieces are in order to win. All information that is shared by the game is shared to both black and white. There are many variations of Kriegspeil, and each variation reveals different information. The more information you have, either directly or though deduction, the easier it is to win!
To play Kriegspiel you only need to know the rules of chess. All moves must conform to the normal rules of chess. When you make a move, it is announced and the turn changes - but the piece and square are not announced. If you attempt to make an illegal move, the attempt will be announced to both players. When it is your move, you can request 'Are there any pawn captures available?'. If there are, you must try at least one. When an 'impossible' move is attempted (for example moving a knight like a bishop or requesting pawn captures when there are no pawns), the action is simply ignored.
Like chess, the game is over when a player is checkmated or stalemated, a draw is agreed, or a player resigns. When the game is finished you will have the pleasure to replay the full game and see how both you and your opponent was moving (and hilarity usually ensues).


Some of our projects have been completed in the past few years.
{{ project.title }}
For all the projects are listed here.


Drown yourself into the playlists we create for you and we'll set the mood.
Take a break, relax with us and enjoy the unique sound.
Whatever the mood, shuffle into the genres we have for you.
Join us moving forward as we create an ethereal experience for you.


OverviewlibCoroutine is a simple stackfull coroutine implementation. On unix platforms, the implementation uses ucontext if available or with setjmp/longjmp otherwise except on OSX where some assembly is used. On windows, fibers are used.
MainFirst you'll need to create a coro instance to represent the C stack that was allocated to run the host program's main() function:Coro *mainCoro = Coro_new(); Coro_initializeMainCoro(mainCoro); StartingTo create a coroutine:Coro *newCoro = Coro_new(); Coro_startCoro_(currentCoro, newCoro, aContext, aCallback);currentCoro should be a pointer to the currenting running coroutine (which would be mainCoro, if this is the first corountine you're creating). aCallback is a function pointer for the function which will be called when the coroutine starts and aContext is the argument that will be passed to the callback function. SwitchingTo switch to the coroutine:Coro_switchTo_(currentCoro, nextCoro); FreeingCoro_free(aCoro);Note that you can't free the currently running coroutine as this would free the current C stack. StacksYou can check to see whether a corouinte has nearly exhausted its stack space by calling:Coro_stackSpaceAlmostGone(aCoro);This returns 1 if the remaining stack space is less than CORO_STACK_SIZE_MIN. The define CORO_STACK_SIZE can be used to adjust the default stack size. There is also a #ifdef on USE_VALGRIND which, when enabled, will register stack switches with valgrind, so it won't be confused. ChainingA trick to provide effectively get unlimited stack space while keeping stack allocations small is to periodically call Coro_stackSpaceAlmostGone() and create a new Coro in which to continue the computation when the stack gets low.CreditsI (Steve Dekorte) mostly just put together bits of code from other folks to make this library. Russ Cox deserves the most credit currently for the portable ucontext code. Some history:
Originally based on Edgar Toernig's Minimalistic cooperative multitasking
(http://www.goron.de/~froese/) |


PHOTO STUDIO BB
Find your inspiration.
Put your creative energy to work, with BB Photo
Get inspired and share your best photos
Get inspired and share your best photos
❮
❯


|
SNP java part
0.0.1
|
Static Public Member Functions | |
| static void | registerDefaultNodeConfiguration (boolean drawShadows) |
| static void | configureDefaultRealizers (Graph2DView view) |
| static void | applyRealizerDefaults (Graph2D graph) |
| static void | applyRealizerDefaults (Graph2D graph, boolean applyDefaultSize, boolean applyFillColor) |
| static void | applyFillColor (Graph2D graph, Color color) |
| static void | applyLineColor (Graph2D graph, Color color) |
| static void | initLnF () |
Static Public Attributes | |
| static final String | NODE_CONFIGURATION = "DemoDefaults#Node" |
| static final Color | DEFAULT_NODE_COLOR = new Color(255, 153, 0) |
| static final Color | DEFAULT_NODE_LINE_COLOR = null |
| static final Color | DEFAULT_CONTRAST_COLOR = new Color(202,227,255) |
Provides default node and edge realizer configurations used by most demos.
|
static |
Applies the given fill color to all nodes
|
static |
Applies the given fill color to all nodes
|
static |
Applies NodeRealizer defaults to all nodes. Properties not applied are location and size.
|
static |
Applies NodeRealizer defaults to all nodes. Properties not applied are location, and, depending on the given arguments, size and fillColor.
|
static |
Configures the default node and edge realizer of the specified view's associated graph.
The default representation used for a node is provided by a y.view.GenericNodeRealizer that uses the configuration mapped to NODE_CONFIGURATION. The default colors (fill, border) for a node are set to DEFAULT_NODE_COLOR, and DEFAULT_NODE_LINE_COLOR, respectively.
The default representation for an edge is provided by a y.view.PolyLineEdgeRealizer with a standard arrow used on its target side.
`
|
static |
Initializes to a "nice" look and feel for GUI demo applications.
|
static |
Registers the default node configuration for yFiles demo applications. This method is called automatically when the DemoDefaults
class is initialized.
| drawShadows | if true , a drop shadow is drawn for nodes that use the default configuration; otherwise no shadow is drawn. |
|
static |
The default secondary or contract color used by most demos
|
static |
The default node fill color used by most demos
|
static |
The default node line color used by most demos. This is set to null
meaning no border is drawn.
|
static |
The Name of the GenericNodeRealizer configuration of the default node used by most demos.


Init-time Configuration structure for EDMA3 controller, to provide Global SoC specific Information. More...
#include <edma3_rm.h>
Data Fields | |
| uint32_t | numDmaChannels |
| uint32_t | numQdmaChannels |
| uint32_t | numTccs |
| uint32_t | numPaRAMSets |
| uint32_t | numEvtQueue |
| uint32_t | numTcs |
| uint32_t | numRegions |
| uint32_t | dmaChPaRAMMapExists |
| Channel mapping existence. | |
| uint32_t | memProtectionExists |
| void * | globalRegs |
| void * | tcRegs [EDMA3_MAX_TC] |
| uint32_t | xferCompleteInt |
| uint32_t | ccError |
| uint32_t | tcError [EDMA3_MAX_TC] |
| uint32_t | evtQPri [EDMA3_MAX_EVT_QUE] |
| EDMA3 TC priority setting. | |
| uint32_t | evtQueueWaterMarkLvl [EDMA3_MAX_EVT_QUE] |
| Event Queues Watermark Levels. | |
| uint32_t | tcDefaultBurstSize [EDMA3_MAX_TC] |
| Default Burst Size (DBS) of TCs. | |
| uint32_t | dmaChannelPaRAMMap [EDMA3_MAX_DMA_CH] |
| Mapping from DMA channels to PaRAM Sets. | |
| uint32_t | dmaChannelTccMap [EDMA3_MAX_DMA_CH] |
| Mapping from DMA channels to TCCs. | |
| uint32_t | dmaChannelHwEvtMap [EDMA3_MAX_DMA_CHAN_DWRDS] |
| Mapping from DMA channels to Hardware Events. |
Init-time Configuration structure for EDMA3 controller, to provide Global SoC specific Information.
This configuration structure is used to specify the EDMA3 Resource Manager global settings, specific to the SoC. For e.g. number of DMA/QDMA channels, number of PaRAM sets, TCCs, event queues, transfer controllers, base addresses of CC global registers and TC registers, interrupt number for EDMA3 transfer completion, CC error, event queues' priority, watermark threshold level etc. This configuration information is SoC specific and could be provided by the user at run-time while creating the EDMA3 RM Object, using API EDMA3_RM_create. In case user doesn't provide it, this information could be taken from the SoC specific configuration file edma3_<SOC_NAME>_cfg.c, in case it is available.
Number of DMA Channels supported by the underlying EDMA3 Controller.
Number of QDMA Channels supported by the underlying EDMA3 Controller
| uint32_t EDMA3_RM_GblConfigParams::numTccs |
Number of Interrupt Channels supported by the underlying EDMA3 Controller
Number of PaRAM Sets supported by the underlying EDMA3 Controller
Number of Event Queues in the underlying EDMA3 Controller
| uint32_t EDMA3_RM_GblConfigParams::numTcs |
Number of Transfer Controllers (TCs) in the underlying EDMA3 Controller
| uint32_t EDMA3_RM_GblConfigParams::numRegions |
Number of Regions in the underlying EDMA3 Controller
Channel mapping existence.
A value of 0 (No channel mapping) implies that there is fixed association between a DMA channel and a PaRAM Set or, in other words, DMA channel n can ONLY use PaRAM Set n (No availability of DCHMAP registers) for transfers to happen.
A value of 1 implies the presence of DCHMAP registers for the DMA channels and hence the flexibility of associating any DMA channel to any PaRAM Set. In other words, ANY PaRAM Set can be used for ANY DMA channel (like QDMA Channels).
Existence of memory protection feature
Base address of EDMA3 CC memory mapped registers.
| void* EDMA3_RM_GblConfigParams::tcRegs[EDMA3_MAX_TC] |
Base address of EDMA3 TCs memory mapped registers.
EDMA3 transfer completion interrupt line (could be different for ARM and DSP)
| uint32_t EDMA3_RM_GblConfigParams::ccError |
EDMA3 CC error interrupt line (could be different for ARM and DSP)
| uint32_t EDMA3_RM_GblConfigParams::tcError[EDMA3_MAX_TC] |
EDMA3 TCs error interrupt line (could be different for ARM and DSP)
| uint32_t EDMA3_RM_GblConfigParams::evtQPri[EDMA3_MAX_EVT_QUE] |
EDMA3 TC priority setting.
User can program the priority of the Event Queues at a system-wide level. This means that the user can set the priority of an IO initiated by either of the TCs (Transfer Controllers) relative to IO initiated by the other bus masters on the device (ARM, DSP, USB, etc)
| uint32_t EDMA3_RM_GblConfigParams::evtQueueWaterMarkLvl[EDMA3_MAX_EVT_QUE] |
Event Queues Watermark Levels.
To Configure the Threshold level of number of events that can be queued up in the Event queues. EDMA3CC error register (CCERR) will indicate whether or not at any instant of time the number of events queued up in any of the event queues exceeds or equals the threshold/watermark value that is set in the queue watermark threshold register (QWMTHRA).
| uint32_t EDMA3_RM_GblConfigParams::tcDefaultBurstSize[EDMA3_MAX_TC] |
Default Burst Size (DBS) of TCs.
An optimally-sized command is defined by the transfer controller default burst size (DBS). Different TCs can have different DBS values. It is defined in Bytes.
| uint32_t EDMA3_RM_GblConfigParams::dmaChannelPaRAMMap[EDMA3_MAX_DMA_CH] |
Mapping from DMA channels to PaRAM Sets.
If channel mapping exists (DCHMAP registers are present), this array stores the respective PaRAM Set for each DMA channel. User can initialize each array member with a specific PaRAM Set or with EDMA3_DRV_CH_NO_PARAM_MAP. If channel mapping doesn't exist, it is of no use as the EDMA3 RM automatically uses the right PaRAM Set for that DMA channel. Useful only if mapping exists, otherwise of no use.
| uint32_t EDMA3_RM_GblConfigParams::dmaChannelTccMap[EDMA3_MAX_DMA_CH] |
Mapping from DMA channels to TCCs.
This array stores the respective TCC (interrupt channel) for each DMA channel. User can initialize each array member with a specific TCC or with EDMA3_DRV_CH_NO_TCC_MAP. This specific TCC code will be returned when the transfer is completed on the mapped DMA channel.
| uint32_t EDMA3_RM_GblConfigParams::dmaChannelHwEvtMap[EDMA3_MAX_DMA_CHAN_DWRDS] |
Mapping from DMA channels to Hardware Events.
Each bit in this array corresponds to one DMA channel and tells whether this DMA channel is tied to any peripheral. That is whether any peripheral can send the synch event on this DMA channel or not. 1 means the channel is tied to some peripheral; 0 means it is not. DMA channels which are tied to some peripheral are RESERVED for that peripheral only. They are not allocated when user asks for 'ANY' DMA channel. All channels need not be mapped, some can be free also.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object net.parallaxed.bluejam.evolution.TreeBreeder
public class TreeBreeder
TreeBreeder is the default implementation of the Breeder interface for recombining and mutating NoteTrees, given an initial skeletal population. Unlike other algorithms, this is not a singleton, since there may be more than one breeder available at any one time. TODO Check working implementation of other NoteSequence representations.
| Constructor Summary | |
|---|---|
TreeBreeder()
Instantiates a TreeBuilder trivially. |
|
TreeBreeder(int maxBreedCycles,
double crossoverProbability)
Instantiates a TreeBreeder with the passed parameters. |
| Method Summary | |
|---|---|
void |
breed(Population population)
Uses a skeletal population containing a collection of parents and fills up the population to the full memberCount quota using methods of crossover and mutation. |
double |
crossoverProbability()
|
void |
crossoverProbability(double probability)
NOTE: Setting this variable also sets the probability for mutation in this breeder. |
int |
maxBreedCycles()
|
void |
maxBreedCycles(int cycles)
Sets the maximum number of times we run a breeding process for each Individual pair. |
void |
recombine(NoteTree nt1,
NoteTree nt2)
Performs crossover on two passed NoteTrees in-situ. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public TreeBreeder()
public TreeBreeder(int maxBreedCycles, double crossoverProbability)
maxBreedCycles
- crossoverProbability
- | Method Detail |
|---|
public int maxBreedCycles()
public void maxBreedCycles(int cycles)
cycles
- The number of times to runspublic double crossoverProbability()
public void crossoverProbability(double probability)
probability
- A value between 0-1 (inclusive).public void breed(Population population)
breed
in interface Breeder
population
- The population to breed.public void recombine(NoteTree nt1, NoteTree nt2)
nt1
- A note tree to recombinent2
- The note tree to combine with.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Organisers' Guide
This guide is intended for organisers of Leancamp, but we’re happy to support other events, in and out of entrepreneurship. Feel free to use our techniques and to ask us for support.
The text of this guide is available under Creative Commons: Attribution-ShareAlike 3.0 Unported however various logos, images and trademarks may have been used to which rights are held by their respective owners. Please be careful to honour them.
You’re welcome to join us and work with us, but unless you do, we don’t give permission to use our name, branding or endorsement. The Leancamp name, logos and brand are trademarks of Salim Virani.
Since the Leancamp model is based on ticket sales, we depend on control of our name. So until you’re named on our website as a Leancamp Organiser, please do not use the Leancamp name or associate with it for your event.
If you have any questions, please contact us.
Credits
Thanks to the main contributors to this guide: Ben Aldred, Ahmad Bakhiet.
Thanks to Saul Albert and Nicky Smyth for co-founding Leancamp with me in those uncertain early days.
Thanks to the Leancamp Leaders who’ve gotten involved since then, making so many contributions – organising, helping share knowledge, and helping steer Leancamp as it’s grown.
Thanks to Ahmad Bakhiet, Past President of the UCL Entrepreneurship Society, who wrote the initial checklists.
Thanks to Kevin Prince and Cristiano Betta, the organisers of Barcamp London, for showing me the Barcamp way before Leancamp was born.
Thanks to Eduardo Comba (flickr: ecomba), Daniel Morris (flickr: anima), and wilgengebroed on ofey for sharing their photos.
Salim Virani, Founder, Leancamp
Getting Started
Thanks for volunteering to organise Leancamp!
Leancamp is for the startup community, by the startup community.
There are 3 I’s to keep in mind:
- Internationally-connected
- Interdisciplinary
- Inclusive
If you’re leading a Leancamp, it’s really more about curating and convening than organising. We’re going to bring together the right people to create a new environment that will make a contribution the global startup community.
This means we make sure organisers have an as easy, stress-free time as possible – and can focus only on the needs of the community.
So, Leancamp is radically different from most startup events. We’ve removed things like up-front payments, the need to get sponsors, and the need to build a big team.
Important: This guide is the culmination of a lot of diverse experience running Leancamp. If you’ve run other events before, a lot of the Leancamp Way won’t be the same as what you’re used to. Those that follow the guide tend to find Leancamp is less work and more value than other events. Those that don’t usually create more work for themselves and others.
The Quickstart will get you rolling, and you’ll be able to learn as you go. As you do, you’ll understand how the way we do things is going to save you a ton of time, and how you’ll be powerful catalyst in your startup community.
The first thing you need is to get in touch with Sal. He’ll be your advisor.
What is Leancamp?
Leancamp is an open, interactive, multi-track event – which connects people who actually do Lean to the doers in related areas of practice. It’s a high-energy day focused on broad learning and helping each other.
Leancamp is a bustling conference, with tons of rooms and fast, 30-minute sessions on different topics. Sessions are usually a short talk followed by a discussion, but are often workshops or other interactive formats.
The difference from a standard conference is that the sessions are planned by the participants that day!
Everyone has the power over the agenda, to contribute their experience, and to interact with thought-leaders and experienced founders. Participants drive the topics based on their needs.
We use a technique known as Open Space, which is what Unconferences and Barcamps use.
Leading up to Leancamp, participants share what sessions they’d like to host. Leancamp starts with an empty schedule. People come on stage to explain their session for 30 seconds, and choose a place and time from the empty slots. An hour later, we have a conference built for and by the participants! (It works like magic - we’ll teach you how to do this magic trick!)
Why is Leancamp valuable?
This format does a number of things:
- It helps people where they need help now. The topics are way more relevant than a conference.
- It brings different communities together to reveal new and unique approaches. For example, Lean Startup, Business Model Design and UX all came together at Leancamp.
- It creates strong and useful local relationships, the bedrock of a new community. This is valuable for conferences and new startup communities.
- It gives rise to local thought leadership, and in doing so, creates recognition for smaller communities on a global stage.
Quickstart (and overview)
Here’s a general idea of how things work overall. Sal will help you learn the Leancamp Way as you go.
The first thing is to seek the easy path:
- Get in touch with previous Leancamp Leaders to help you. You’ll find them on our Slack channel, and Sal can make intros if you’d like.
- Contact local conferences to open partnership discussions. The basic idea is that conferences benefit from including Leancamp under their umbrella. They get:
- a much stronger sense of community at their conference, because Leancamp runs first and sparks a lot of relationships between conference attendees.
- stronger grassroots startup credibility, since Leancamp is a startup-friendly price and attracts well-respected founders and experts
- access to a better set of speakers, since strong founders are often motivated to come to Leancamp more than more formal conferences
We’ve had some serious successes here, starting with TNW conference, and most recently powering the 700-person Pirate Camp in Cologne!
If the partnership route doesn’t work out, here’s plan B:
- Get 2-3 local organisers involved. Ideally, someone who’s seen an open space before. You don’t need a bigger team, yet.
- Start building the email list at http://leancamp.co for your city. This is very important, as it’ll make our lives much easier once the venue is confirmed and we need to sell the first tickets. We can create a special link for you that defaults to your city name. (It’s a standard Mailchimp form.)
- Before moving on to the next steps, you need Sal and another experienced Leancamp Leader on your team as advisors. Your Advisor’s job is to provide continuity, so your Leancamp experience is consistent with other cities. You’ll talk to them on a regular schedule.
- Sit down with your Advisors to walk you through the budget of previous events. Then make your budget together. This takes around 30-40 minutes.
Get an idea of necessary ticket prices and volumes to break even. You’ll plan out 2 more budgets, the “relax” point where we’ll no longer need to hustle to sell tickets, and the maximim size, when we can add a lot of extras to make a better event.
- Find a venue. Make requests to all possible Venue Partners at once. (We’ll cover strategies and email templates later.)
- Start reaching out to invite local community leaders to be Leancamp Ambassadors.
- Once a date is set, announce the event and release Fast Mover tickets.
- Start the Countdown Automation for your city in Mailchimp. This will get the conversations going about topics. Setup your event as a category at leancamp.uservoice.com and encourage speakers and ambassadors to suggest sessions there.
- One month before the event, we assess our break-even position and make a go or no go decision. If it’s no go, we announce a postponement and refund everyone.
- After Fast Mover tickets are sold, we look at who’s attending and consider balancing the event out.
Balance is really important to make a good Leancamp. (There’s a whole section on this below.)
If there’s one group that is particularly strong, we don’t want them to overwhelm the event, so we release tickets access codes for discount tickets to underrepresented communities with the help of our Ambassadors.
- The event itself is quite easy to run. You’ll need a team of 6 volunteers, and can usually get them through a local university. There’s be a bit of preparation the week before for catering, and the day before for the venue. All of that is easy - just follow the checklists.
Leancamp Community Ethos
Putting your city on the map
Global startup culture is becoming more networked and less top-down. There’s a lot we can learn from Silicon Valley’s example, but to succeed, we must build on our own strengths and on our own terms.
Taking off the blinders that come from outside definitions of what makes a good startup, we find communities of other types of role models, and invite them to share. In doing so, we give rise to locals - not just the usual suspects who are already known, but local unknowns who are on the rise and have something useful to teach us.
Leancamp, like emerging startup communities, doesn’t play a zero-sum game. We draw on the best by embracing connections to other places. That way, Leancamp cities learn from thought leaders from other Leancamp cities, and in this grassroots way, both the people and the community itself become visible to the world.
Benefits to the local community
Leancamp is something people join, not attend.
We’ve seen Leancamp galvanise local startup communities. This happens by drawing on unlikely local startup supporters, and helping local cliques meet and help each other.
You’ll strengthen your local startup community because instead of just flying in external experts for a day, you’ll build up local strengths and help them build relationships with international leaders.
There’s a growing list of notable startup leaders who will happily jump on a plane for Leancamp – they’re a welcome committee for your city!
Little Startup Superheroes
The culture we want to encourage is of humility, acceptance that we all have a lot to learn, and of a practical attitude to what works, what doesn’t and in what context.
It’s great when we’re graced by startup superheroes but that’s a bonus. They, just like everyone else, stand up and offer their session in the morning planning session. It’s a democratic system.
This overrides the reverence we have to superstars, and allows us to focus on learning something useful for us in our own context. It’s way more effective to learn from someone who is 6 months or 1 year ahead of us, not just those who made it super-big.
This is how we get local stars like Andreas Klinger, Des Traynor, Stephen Rapoport, Johanna Kollmann, Lukas Fittl and Tendayi Viki – people who keep strengthening their local startup community.
Leancamp builds community by identifying our emerging startup leaders, and giving them a platform to help others.
6 ways Leancamp is different.
We’re about knowledge-sharing - inclusive to all.
We want to learn from each other. We want to seed a culture of sharing experiences, being open and humble about what doesn’t work, and of seeking to learn from other communities rather than create cliques and exclusivity. Leancamp played a big role in connecting entrepreneurship to user experience design, and Lean Startup to Business Model Generation.
We want to continue this tradition of connecting communities.
We highly value local and practical knowledge.
Connecting to others actually doing this stuff is hugely valuable. It’s the doers who push the state of the art, and they’re right at home. External people add to this, help build excitement, and create international relationships into your city, but the real value is in engaging the local community in a new way.
No sponsors.
Leancamp is for us, by us.
We stay focused on that by keeping costs down and paying our own way.
We’ve tried sponsorship in many formats in the past, and while, at first or in tough times, it feels like an easy win, in every case it has come back as an extra distraction to manage when we really needed to focus on the core event.
If people approach us to sponsor, that’s great! We can use their help. Check the FAQ for ways they can contribute.
Every other type of sponsorship is effectively selling our audience which contravenes the ethos of for us by us.
 This means that there is no work in getting sponsors, or in managing sponsor expectations for the Leancamp team. The sponsorship money is provided by the parent organisation.
Our customers are our participants, not corporate sponsors.
Nobody gets paid.
Not even if you wrote a book! :)
This keeps things real and simple. With money off the table, we’re all aligned in a common community goal. Help people with their startups.
People first.
People are our core, measurable unit. Not startups or methodologies or investment rounds or content.
Our goal is to help people improve and achieve their goals, and help them find others who will help them on their journey. Thus, Leancamp puts a strong emphasis on people over everything else.
You won’t see organisation logos all over Leancamp, instead we’ll raise the profile of the people in those organisations who want to contribute. They are the champions that deserve to be heard, and people will only respect their organisations as a side-effect of respecting them.
You also won’t see people rallying around a certain approach. Instead, you see leaders describing where they’re at now, and discussing what to improve.
You will likely see people with books to sell, or some equivalent! But the emphasis is on the author, not their product, and Leancamp gives them the freedom to make further contributions unconstrained by their previous publications. For example, Brant Cooper and Alex Osterwalder put on workshops at Leancamp that were new and experimental.
So even though we’ll attract Lean, Agile and Design leaders, the tone of conversation we need to create is more realistic than dogmatic.
We keep it real at Leancamp.
No room for egos.
Just like sponsors can’t buy their way in but are welcome to contribute, nobody gets to “keynote” or gets preferential treatment. Everybody suggests their sessions together and the participants retain the option of voting with their feet.
On top of that, this frees us to work on an awesome event, rather than devote extra attention to specific people.
That said, recognized contributors should be promoted on the events page, and as with anyone else, we should help advise them about what the should do or what topics they should cover.
We can also offer to waive their ticket fee and possibly to pay for their flights if we can afford it. Many contributors are happy to buy their own flight, and take the risk of being reimbursed if we make the ticket sales.
Your Role As An Organiser
At most conferences, the role of the organiser is to choose speakers and talks, and to sell sponsorship and tickets. Leancamp is different.
Rather than curate a conference, you’ll be curating communities, building an intersection of topics by liaising with other community leaders, and encourage local practitioners to share their experiences.
Your main responsibility isn’t to make a big event that makes money, it’s to create a balanced event that fosters sharing and peer support.
Where to focus to succeed.
Our satisfaction scores plateau at 60 people. After that, making the event bigger will not make it better!
Again because it’s important - a great Leancamp is around 60 to 100 people. Bigger is not better!
The size of the event will take care of itself over time. Engage the right balance of communities, and your Leancamp will grow on it’s own. Don’t worry if the first Leancamp is small. If the people there benefit, word will spread. You’ll create demand; next time will be so much easier.
So don’t stretch yourself to hit bigger numbers! Save your energy.
The Core Leancamp Process
Leancamp has a core process which has evolved over multiple events in different parts of the world. The core process is something we must stick to, otherwise we risk consequences that can suck up a lot of time and stress, or detract from the events quality and the Leancamp name. (We’ve learned from our mistakes!)
Ideas & experiments
Check in with Sal to talk though any experiments you want to run. He’s seen a lot of them already and will guide you on where to stick to what works.
When we have ideas to improve things, we love to experiment! With experiments, we get the Leancamp Leaders involved and we need to apply the PMCA loop. That is, we’ll test them with some controls and a fall-back position, and measure their effect overall to ensure they are delivering more value the Leancamp participants.
If they prove of benefit, we’ll roll them into the core process for every city to benefit!
Affordable Loss & Runway
Leancamp, like most startups and non-profits, can’t afford to lose money. Plus, we don’t pass the financial risk onto our local organisers. So, we work together, and manage our financial risk through MVPs.
The Leancamp Minimum Viable Product
Our first learning goals is: Is there enough demand for the event to break even?
Sit down with your Advisors and look at budgets of previous Leancamp together. Come up with a budget for a minimal Leancamp for around 60 people. Work out a ticket price. This will be promoted as a First Mover ticket - and will be the cheapest ticket we offer. At this point, we’ll announce the prices for later tickets. Usually, First Mover tickets are around 50 EUR. Full price are 150 EUR and most tickets get sold at the mid-tier: 100 EUR.
The Leancamp MVP is no more than announcing Leancamp is coming, and naming one or two speakers. This should attract a core group of true early adopters who want to participate without knowing exactly who will be speaking.
An important part of this is we are attracting good contributors and will make the event more valuable to everyone else.
Selling these first tickets is our first real validation signal. Based on these revenues, we can make an informed decision of if we’re going to break even.
If we can’t break even on this, we accept this as a signal from the market, and we need to go back to better understand the market before we try again.
Planning by getting options
Whether you’re asking a venue or speakers for availability dates, or considering topics for talks, or almost anything else, it’s important to always get a range of options.
Making Leancamp work has many different moving parts. Making the best Leancamp possible comes from communicating options to others so we can select an optimum together.
For example, with venues, don’t ask for a single date. Instead, get a range of possible dates from the venue, so we can narrow that down later based on other constraints (availability of speakers, other events popping up, other Leancamps bringing in speakers we can share, etc.)
We’re way more likely to get a great speaker lineup and great turnout by communicating date options, rather than just choosing a date in isolation.
Don’t optimise by yourself. Communicate options frequently and promiscuously, to your Ambassadors and the Leancamp Leaders. Optimizations will appear.
Choosing a location
See the checklist section for our venue requirements.
Generally, we only work with venues operated by people who already support startups or innovation, and who have someone personally interested in supporting Leancamp. Things go much more smoothly when we’re aligned in our goals, and have an internal ally, rather than simply a venue offering space.
Typically, we work with universities or training facilities. They’re usually quite keen to work with us to be more closely connected with entrepreneurs, because they tend to be good citizens, and also because we offer their students authentic exposure to a leading entrepreneurial community.
For university entrepreneurship societies, we normally offer an allocation of free tickets for their students, plus give even more students access as volunteers.
Getting the go from Hosting Partners
As soon as you have your Advisor, we’re going to build a localised buzz around all our possible venue partners, letting them know who the prior hosts were and how they benefitted.
We usually go with the first that comes back saying, “Great! Let’s do it. What do you need?” This means they’re a true partner and will align with us, work with us well and generally make our life easier. (As opposed to people who don’t think of it as a common goal and start treating it like a negotiation.)
To get a venue partner in cities where we’re not well-recognised, we need to do some social engineering. This has two parts:
- We create a sense of excitement. This is done by activating as many introduction as possible to the same people and organisations. If a potential partner hears about us from more and more people, they are more likely to get excited about the possibility. When people keep hearing about Leancamp, they know it’ll be significant so are more likely to act. Name dropping our partners in other cities and our past supporters is helpful, but set expectations to be about building community, not having famous people show up.
- We create a sense of urgency. We are clear that we are approaching multiple partners, but there can be only one, and we’ll work with whoever sees mutual benefit and wants to start right away. Universities can be competitive so will often act on the basis of getting in first. (This can also backfire if they want to exclude their rivals, so we must quickly emphasise the inclusive aspects later, and make specific efforts to include the faculty and community around venues that didn’t get to host.)
It’s fine to email them cold, but ideally, you can get warm introductions through the ambassador network and the Leancamp Leaders, so share the list of your target venues with everyone on Slack in #leaders so we can find good connections in.
Picking speakers
The idea of “a speaker” is really different at Leancamp.
Speakers don’t prepare talks and aren’t chosen on their oratory skills.
Instead, with the help of local community ambassadors we choose speakers based on their experience and how it can be useful to others.
Instead of preparing a talk, we ask them to think of 2 or 3 topics with personal stories they can tell. We’ll let the audience chose on the day, and the stories really only need to be 5 to 10 minutes long. The real value in the session will come from the 20 minutes discussion that emerges.
-
Start by asking local ambassadors for local role models with interesting and unique experiences to share.
-
Then gain access to the Master Seed Speakers Board we have in the Leancamp Trello account. (Your advisors can give you access.)
Copy the board, then rename it to your city. Everyone on this board has be a Top 3 speaker at a previous Leancamp. You can delete speakers you don’t want to invite.
- Add more speaker ideas to your board. The best additions won’t be typical startup or Lean Startup people, but rising stars in other communities you want to connect. Ask your local ambassadors for ideas here.
Save the bigger name invititations for when the event gets bigger. (Most globally recognised names are happy to help, but only when the event is at least several hundred people. See “Big Names” below.)
- Start inviting, keeping in mind your budget and the number of flights you can currently afford. Don’t invite anyone unless you can afford their flight already!
Some people will decline but offer to video call in. DO NOT DO VIDEO CALLS FOR TALKS. They are a logistical nightmare, and are not interactive enough for Leancamp. Politely decline and explain that Leancamp is much more interactive and that we can’t plan around a strong enough internet connection.
- Diversity is extremely important to create a truely powerful and notable Leancamp. This stems from the principle that learning from people in different contexts gives us a broader perspective.
To get diversity right, you need to start off by announcing speakers from all of the edge groups you want to be represented:
- small communities of practice
- gender
- ethinicity
By presenting a truely diverse set of speakers from the beginning, you’ll be communicating welcomeness and inclusiveness to all, and plant the seeds of the Leancamp brand - as the place to learn from the most diverse sources.
It’s okay if the speaker lineup becomes doesn’t become more diverse later. The important thing is start as diverse as possible - it makes sure everyone feels welcome and able to contribute.
For more on this and why it’s necessary, see Keeping Balance below.
Learning from the metrics
We email our waiting list and make noise, taking a close look at 2 numbers on our landing page:
- The conversion rate
- The number of unique visitors
We watch these numbers from the beginning, and let them inform our Customer Development efforts.
At first, both Organisers and Ambassadors should plan on a bit of time for Customer Development, as we’re trying to open a new market for Leancamp, so will need to understand our customers’ buying decisions and how we can make Leancamp valuable to them.
After the first ticket release, we should get to a point where we have a comfortable conversion rate, around 7-10% for now, as this will drop later when we reach out to people who aren’t as personally connected to the event.
Genrally, we’ve found these numbers to be good predictors and warning signs. If these benchmarks aren’t accurate for your city, bring numbers from previous startup events in the same city to discuss with your advisors.
Responding to low ticket sales
If the conversion rate is low, below 7% early on or below 2-3% after the break-even point, then there’s a problem. We don’t understand the market well enough and we need our Ambassadors to get on the phone and talk to their people about the event. They need to do a little more talking to people to find out why their community isn’t buying.
If the conversion rate is healthy but unique visitors is low, there’s an awareness problem, so talk to Ambassadors about what we can do to spread the word better. We probably have to make more noise and reach out to more ambassadors and build more awareness channels. Get the word out on more email lists, blogs, announcements at events, event listings, etc.
Your Advisor will be able to draw on previous Leancamp experiences to shed light on this.
The point of no return
If our Fast Mover tickets don’t sell well, we can learn and adapt. If we have less than a 4-6 weeks though, we have to discuss if we should cancel or postpone the event, and refund everyone. This gives us a safe point of no return.
If we cross it, we should be confident we won’t lose money and we know the event will be a success. So we can try to grow and improve it, but it’s all upside!
From now on in, we have a responsibility to the participants for their experience. If in doubt about a decision, ask what’s the right thing to do for the people who’ve already bought tickets. They have entrusted their money and contributions to us on their behalf.
Keeping financial risks under control
After the break-even point, we only incur costs that we can pay for with money already collected. This not only makes the event break-even, but also cashflow-positive, which makes our lives a lot easier.
Relaying on people to pay us later is recipe for a lot of stress and extra work later. Avoid this situation and only rely on up-front revenue.
Iterating and improving
Once we have enough extra cash to buy some more plane tickets, we invite and announce new speakers and leaders from other cities, both local and regional, known and unknown. Start with the Seed Speakers list since they have given the best sessions in the past. When they attend, you know they’ll make it a better Leancamp.
Past the break even point, we don’t need to sell more tickets, so we can turn our full attention create the best possible experience for our participants. Extra ticket sales are still great - with that money, we can make some improvements - but our main focus can move from selling to curating. (The great thing here is that better curation will now lead to better sales since our marketing channels are functioning well.)
As we release batches of tickets, we reduce the discount. This pushes people to buy tickets sooner and allows us to add bigger costs based on the event’s momentum.
Big names
Announcing better-regnised names as speakers has a negative effect - it will attract people who just want to sit and listen, rather than participate. This is the opposite of the early adopters we want - the people actually in-the-know enough to recognise the value in the community and the smaller names.
Since Leancamp is good because it’s peer to peer, it’s those early adopters we need first. They have something to share too.
So hold off on announcing the bigger names until later, when we have a good balance and a majority of eager contributors. (See MVP.)
When we have the size and can cover the cost of business class flights, we put the word out to internationally-recognised leaders to see if they’re interested and available.
Ask Sal to invite these people. He already has these relationships so it’s a friendlier ask, easier for everyone and more likely to get a yes. This also makes sure they have consistent contact with Leancamp, so we aren’t repeating ourselves and annoying them with multiple requests.
It’s usually best to save the big names for a Leancamp that isn’t the first in a city, when we have the bugs worked out, and have a bit more demand so can offer a bigger audience.
Your tools and gauges
Keeping Balance
Balance is the key as you grow Leancamp.
We want Leancamp to be a place where people learn new things, and meet people they don’t normally meet in their regular lives. This leads to the best feedback from Leancamp participants: “I met so many helpful people who I’d never meet anywhere else - and they’re going to help me do X!” This helps strengthen all the communities involved.
If one particular community dominates Leancamp, our event will suffer. It will be hard to encourage an inclusive culture and hard to leave a legacy of spotting emerging local talent.
Ideally, we’d aim for 50%-70% startups and 30-50% non-startups. Within the startup community, we also want to make sure there are multiple “cliques” so one group doesn’t dominate.
Another rule of thumb is that we want 90%+ active doers. (Try to limit consultants to 10% max as the event isn’t well-suited for them and we’ve found that more than 10% consultants drags down the satisfaction ratings for them and everyone.)
Here are a few rules of thumb that we aim for:
- Around 50-60% actual startup founders.
- Around 10-20% corporate.
- At least 25%-50% female.
- No more than 10% consultants. (Though up to 10% consultants is a positive thing, if they share their case studies.)
- No more than 50% technical people.
- At least 10% from any outlier community you’ve invited, like scientists or architects.
- At least 20% designers.
For example, for Leancamp London 2 (2012), we aimed for:
50% startup founders
- Lean Startup London group
- UCL and student enterprise societies
- Minibar / East London startuppers
- Social enterprises
25% UX
5% Scientists
10% Suits (consultants, corporates etc.)
10% Lean/Agile IT
Building our local Ambassador network
Think of your city’s and region’s strengths. Not just in startups. What is your area known for? What are the historic industries? The growing industries? Who are the local leaders?
Scan Meetup.com or the local equivalent. What communities already exist that could add to the diversity of Leancamp?
Having used these questions to explore, you’ll start to get a sense of how your Leancamp can be unique and build on local strengths. Old news to you is novel and valuable to the international crowd!
Reach out to leaders in these different communities (thought-leaders, bloggers, event organisers, accelerators, etc.) that aren’t necessarily connected to startups, but where mutual learning could be useful. For example, UX people tend to like working on startups, and startups can benefit from learning about UX. You can be creative here, and it’s good to err on the side of being inclusive.
Using your Ambassador network to sell tickets
The main goal of selling tickets is:
- To reach the break-even point
- Once broken even, to achieve balance with multiple communities.
We achieve balance at Leancamp by working closely with Ambassadors to different local communities, and by giving them access to discount tickets while public tickets are unavailable. We look at who’s bought tickets already and aim to sell more tickets to underrepresented communities in order to keep a good balance.
For example, if you have a strong science industry or consulting industry in your city, getting an ambassador and possibly 1 “seeded” session, plus 5-10 participants from that community will make for a very unique Leancamp! It’s likely that new approaches will emerge there - and your Leancamp will be known as the source.
Your Ambassador network is a powerful resource. Use it to:
- Work out what areas of learning will be interesting to their community, and what areas they would seek help from other communities. Leancamp is centreed around the startup community, but the Leancamp event benefits largely even when we act as “information brokers” between other communities.
- Get the word out informally at the beginning. Twitter, personal emails, intros etc.
- Get the word out in “scale mode.” Once you’ve learned a topic that’s interesting to their community, they can help get that message on email lists and through other organisations in their world.
We need to make ambassador connections early on, but it gets easier to get them involved as the event becomes closer, so keep trying! If some people haven’t been fully responsive, update them on our progress.
At any point, if you notice you’re not hitting these balance guidelines, it’s time to work with the relevant ambassadors for that community to find out what it’ll take to get more of those people to Leancamp.
The mechanics of ticket releases
We watch who’s bought tickets, looking at
- the discount code they used (since each ambassador gets a unique code)
- how the ticket buer describes themself: Founder? UXer? Consultant? etc.
- their learning goals
Based on this, we know how we’re tracking with balance, so we know who we want to invite more of. If a group is under-represented, we keep public tickets closed, but release special access codes for certain ambassadors to release publicly. (So, if we need more UXers or more people from Startup Group X, we give access codes to those ambassadors.) For a short period, say 2-3 days, they are the only ones who can buy tickets. These codes are usually for the cheapest Fast Mover price, even if that deadline has expired.
A useful trick is to set a discount code for unlimited uses and no deadline, but announce them as only 5 tickets available so people act with urgency. (We’d probably extend the code anyways, so this just saves us the trouble. We can shut down the code whever we want if we have to.)
Seeding sessions
We want everyone to learn something immediately useful and applicable at Leancamp.
The magic of Leancamp happens at the beginning of the day, when the community bubbles up and loads of people offer to run sessions. There has never been a Leancamp where the session board wasn’t full - though when we start, there are lulls.)
Like most magic tricks, there’s a certain preparation underlying it.
We seed (eg. preplan) around 30% of the available sessions. We don’t announce this though - it’s more a personal connection with a few of the seed speakers, asking them to be prepared to step up first. This gets the momentum going for others to propose sessions while also making sure the event is good.
We ask everyone who bought a ticket what they want to learn on the ticket purchase page in Eventbrite. Also add the Ambassadors suggestions to this. Now we have an idea of what sessions we need to seed even though they appear to be regular sessions in the open space planning.
You don’t need to know exact topics, but a short brainstorm on a few broad spaces is enough. In addition to topics, ask each Ambassador who in their community has a story or expertise to share that might be interesting to the Leancamp participants.
This is a great discussion to involve some Leancamp Leaders. Their experience will mean they ask you good questions and make good suggestions.
Tip: Go for some “interesting” outliers. These may not be well-attended, but often lead to more engaged and informal discussions about practical applications. New tools and techniques are seeded here.
Showtime! How the day runs
The organising team arrives 2 hours before the start, normally at 8am and starts setup.
Volunteers are empowered to fix whatever needs fixing. Organisers run around to keep things on schedule, and can dip in to interesting sessions.
By 9am, breakfast is being served and people are trickling in.
The session planning starts at 10am.
By 11am the sessions start, 30 minutes each with a 10-minute break in between. We schedule in lots of breaks, since the miggling time is really important for people to catch up with each other on things that were important to them but went by too quickly in the fast-paced sessions. Usually the schedule is timed like this:
10am Planning Session 11am Session 1 11:40am Session 2 12:20pm Session 3 12:50 Lunch 2pm Session 4 2:40pm Session 5 3:10 Coffee Break 3:50 Session 6 4:30 Session 7 5:10 Wrap up
The day ends with everyone wrapping up in the same room. A show of hands of who learned something they CAN apply next week. Another for those who WILL apply it next week. Feedback forms are handed out, and asked to be completed on the spot. While that happens, people are invited to stand up and quickly share something useful they learned.
Applause. Everyone is directed to the pub!
The volunteers and team gathers for a 10-minute retrospective. Somebody takes notes for the other Leancamp Leaders. We clean up quickly, and join everyone else at the pub.
Session Planning
There’s also a standard 10 minute talk to set the right tone. Don’t deviate from the deck that Sal made! Setting expectations, responsibiitiesn and principles within the community is important to make the day work.
Then onto session planning -
Session planning is pretty easy once you get the hang of it. If you haven’t seen it done before, get an experienced Leancamp Leader to take that role. It’s very important to get right as it sets the tone for the day.
If you’ve seen it done and you’d like to give it try yourself, here are some tips:
- It’s all about energy and excitement. You need to exude happiness and interest in all the potential of the day. You need to be contagious!!!
- There’s an intro deck covering the planning method and Leancamp ethos. Do this fast, in less than 10 minutes, so you can get to the high-energy part of having everyone on stage.
- Embrace the messiness of the process.
- Remember to get people to write their name and social media contact on their card.
- At the beginning, people will get their cards wrong. That’s okay. Stop and help fix them on stage so everyone learns.
- Be transparent. Do what you need to on stage, on mic. Expose the inner workings of the event. People will better understand it and contribute to it.
- Keep people being punchy. Urge them to finish up after 30 seconds. Cut them off after 60 by stepping in and summarising their session idea.
- Suggest fun and punchy session topics. People are bad at writing their own headlines. Summarise each of their explanations with a punchy topic they can write on their card. If you’re not sure your title is correct, ask them.
- If the board isn’t full at the end of the morning planning session, that’s fine. Just try to reschedule the existing sessions to be more heavily-weighted in the morning, and then tell everyone to come back for another short planning session after lunch.
- Adjust the schedule as you go. If you move any card, make sure you get the approval of that session’s host.
- Encourage cross-over. “Oh, you two could host a discussion on X. Up for it?”
Volunteer and logistics management
It’s best to recruit a local student group, ideally an entrepreneurship club, who has already worked together. As organisers, you can then delegate most of the day’s logistics to the leader of the student group, who will already know everyone’s strengths and will be better at delegation and management.
Meet with their leader in advance to talk through the appropriate checklists with them, and work with them as a pair on the preparation on the day.
Measuring Success Overall
We measure success in a few ways:
- Firstly, we have a standard feedback form which includes the Net Promoter Score (NPS). NPS isn’t actually useful by itself since the responses are highly skewed in different cultures, but it will give you a sense of if you’re improving over time.
- If we run experiments with our format, we identify people who have been affected by them in the feedback form, and compare them to people who haven’t. This gives us an idea of if the experiment actually made the event more valuable to people overall.
- We look for sessions that were popular, either in buzz, Twitter chatter or common in the final “what did you learn” session. This shows we’ve spotted a local leader - and a seed speaker for the master list.
- At the end of Leancamp, we do a show of hands to see how many people learned something helpful for an active problem that they can apply next week. We usually hit 95%+.
- We’ve started to ask if anyone made a new connection that can help with a current problem. This will be a more important measurement as Leancamp grows.
- We look through the feedback forms and tally keywords/topics that were mentioned. So what were the most common complaints and suggestions? Also we tally everyone who was a “top contribbutor” The top 3 get added to the master seed speaker trello board.
Resources
- For your events page, use the Leancamp site. It has integrations to our social media and other benefits that will save you a lot of duplicate effort.
- For ticket sales, use our Eventbrite account. We have integrations and automated emails that will save a lot of trouble. Use them! They’ve been tweaked over time to avoid problems!
- We’re also setting up Mailchimp with email automations.
- We have moved from Uservoice to Hackpad for online session discussions. Copy and paste the template into a Hackpad page for your event.
Checklists
Location selection
We typically look for:
- The venue is operated by people who already support startups and/or innovation.
- Overall venue capacity, 60-200+ depending on our goal
- One large room for everyone, either auditorium seating or open-plan. At 60 people, we can get by with common space if they’re happy with the noise. Beyond 80, we need an auditorium for everyone.
- For every 40 people, a sound-isolated room with capacity for 30-40 people. Session rooms ideally are cabaret style or movable chairs and tables.
- Extra smaller session rooms, 5-15 people are also a good idea, especially if the event is over 100 people.
- A central, common space to post the day’s schedule. This will become the hub of the event, so needs to be in an area that can stand 50-60 people around it.
- Wifi that will hold up for techies with multiple devices.
- A/V capabilities in most rooms, including projectors and audio.
- Accessible by public transit.
If any of these are not doable, there are budget implications, so go redo the budgets!
First ticket release
- event page created and tested w/ first speakers and all ambassadors
- announced on Twitter
- announced to email lists
- announced to Leancamp Leaders
- announced to Ambassadors
- post to plancast
- post to lanyrd
- post to f6s
- submit to startup digest
- submit to local lean startup meetup (announce it as a meetup event if possible, for higher conversion)
(take from old Lean events in London guide)
Seeding Sessions (4-2 weeks before)
- About 30% of the sessions slots covered by people who know have prepped sessions, you’ll likely have a full board.
- A handful of “Intro” sessions. (It’s usually best to ask some of the Leancamp Leaders attending if they can cover the intro sessions, and ask them to try to schedule them at the beginning of the day. )
- A handful of more advanced sessions.
- A session on experiments.
- A session on UX
- A session on Customer Development
- A session on metrics.
- A session on a real MVP.
- At least 1 session from each of the Ambassador communities present.
Creating the schedule for the day (2 weeks before)
- Late start so people have 30-60 minutes to arrive and have coffee/breakfast before the planning session starts.
- One hour planning session to start the day.
- One hour for lunch, so people can mingle.
- At least 2-3 session timeslots before lunch so people have a sense of who they want to talk to at lunch.
- Never more than 3-4 sessions in a row without a coffee break. (So people keep their energy up and can make better personal connections.)
- Sessions are 30 minutes.
- 10 minute gaps between sessions to allow people time to go to the board and decide what’s next.
- Final session slot for everyone to regroup in the same room.
- Know what pub to send everyone to afterwards!
Supplies to order (2-3 weeks before)
- Full-size floor camera tripods.1 for each room. (One of the Leaders will fly in with flip cams and SD cards.)
- blue tack x 4 packs
- Large index cards x 200 (for schedule board)
- Small index cards x 2000 (for post ups)
- Masking tape x 10 rolls
- A4 sheets(prime) X 40 sheets per participant
- Sharpies or fine-tip felt pens x 1 per participant
- Name tags x 2 per participant
- Pre-printed A0 schedule sheet x 5
- 5-10 extension chords/power
- A4 Document Wallets x 8 per room (for the crowd-notes) *
(Always err on the side of over-ordering!)
Catering order
Getting catering outsourced allows us to focus on the event itself. Opt for higher-quality food and aim for a €25/person budget.
- Unlimited coffee all day
- Catering staff present for setup and serving (though we can augment serving staff with volunteers to save costs)
- Vegetarian and vegan options
- Coffee, tea, juice and continental breakfast
- Several food options at lunch (better than pizza)
- Snacks at the afternoon break, including juice
- Optional beer starting in the afternoon (budget permitting)
Day before (on-site)
- Access to laser printer
- Access to cloakroom/ luggage room
- Access to secure overnight storage for equipment room temperature control
- extra bin bags
- phone number for security
- phone number for catering
- phone number for building maintenance
- phone number for wifi support
- Check wifi works
- Floorplans printed
Leancamp Day Checklists
Adapt times and number of people needed for each Leancamp.
Needed skills:
- Audio/Video Recording and Management
- Photography
- Lanyrd
Pre-event:
Please arrive at 8am where we will have a detailed debrief but in the meantime you can see a summary of responsibilities below:
Tip: Assign and do the tasks in the order that the customer interacts with Leancamp. So, start with the signs outside, then setup registration, then the main room, then the other rooms. (This will keep everything low stress, and allow us leeway if we’re running late.)
Arrival [All]
8am for brief. (2 hours before event starts.) In attendance:
- Organisers
- Advisor
- Any Leancamp Leaders attending
- Volunteer Team
One Organiser and the head of the volunteer team take the lead. Leancamp Leaders are asked to jump in whenever helpful. Start by thanking everyone, explaining the overall goal of the day, what they are contributing towards and empowering them to make decisions and act in a way to improve things.
After explaining all the different roles, and how the day should play out, allocate responsibilities so each student will have at least half a day free to participate in Leancamp sessions.
Pre-event roles
Camera setup 2 people (45 minutes) Setup tripods and cameras in each room:
- recording in 720p.
- 7 hours or recording time on card
- Well-positioned for unobstructed view (usually to the side of the stage.)
- Within 2-3 metres of speaker so sound is clear
- Somewhere that nobody will block the line of site
- Plugged-in and have power!
- Start recording now!
Registration 2 people
Checking tickets on entry, posting up ‘Getting The most out of Leancamp’ &, Session format posters in each session room. Maps & directions posted up in hallways, stairs, etc.. and any information posters everywhere. Answering any questions attendees have.
Signs 1-2 people (2 hours)
Certain signs will need to be placed near the building to help people find Leancamp. Put up signs in the order that people arrive.
There are pre-printed signs. The ones with Leancamp logos are there for you to draw arrows on. Get a felt marker for this.
- Start in the parking lot and/or local transit point, then put up signs towards the building, then into the entrance and towards the registration.
- Put up a sign at registration to inform people we’re recording.
- Put up signs to point people to the main room from registration.
- Put up signs to point people to each session room, and the cafe/food area, from the location of session board.
- Draw a map of each room and photocopy it. Put one in front of each session room and a few near the session board.
- Also, place do not enter signs on perimeter doors to prevent people wandering around the building or getting lost. “Pivot here!” :)
Catering co-ordinator - 1 head organiser
This should be handled by the person who organised the catering and knows the caterer. They are responsible for making sure the caterer is on time, has what they need, including volunteers to help serve, and that they stick around all day to keep the coffee pouring!
Schedule Board Setup - 1 person
The schedule board will be a physical grid on a movable structure. Or preprint the schedule grid on A0 sheets. Then, this is just a matter of tacking them to a wall.
- Session times going horizontally on top
- Make sure to include columns for the planning session, breaks, lunch and the final session.
- Session room names going vertically down the left.
- Include the resources (projector, audio, etc.)
- Include the room capacity
- Include the room layout (lecture, cabaret, etc.)
At the scheduling session at 10am:
Get a Leancamp Leader to redirect the event page to the Lanyrd page. Update the schedule on lanyrd.com (example for Dublin: http://lanyrd.com/2012/leancamp-dublin/add-session/ ) for each session as they are planned. We will redirect leanca.mp/city page to our Lanyrd page when the event starts. Check the board throughout the day for changes, and update Lanyrd.
Breakfast service 2 people
We will have coffee and food delivered. We need 2 people to take charge of setting this up so the participants can eat when they arrive!
During Event
Time-warnings - 1 organiser in the morning, the other afternoon
5-minute warnings can be done by the head organisers - allows them to see everything and double-check cameras. It also gives the organisers visibility and authority during the event.
Tip Make sure this is done assertively by someone who has had the stage in the planning session or intro. The authority is necessary - people often ignore volunteers who try to call time, but not the organisers.
5 minutes before the end of each session, quickly pop into each session room and announce “5 minutes left.” Interrupt the speaker mid-sentence, it’s okay. You need to move quickly to cover all the session rooms.
When time’s up, do the same again.
Decide now who will do this in the morning, and who will do it in the afternoon.
Room stewards - 1 person per 2-3 rooms
Between sessions, if sessions get too big for their room, send someone from the session to find a room to trade with. If you need to, you can feel free to ask one of the participants to help, so that you don’t need to abandon your current task/role. (A/V people for example.)
- Ensure that sessions start on time. If the last session is running more than 5 minutes over time, take over the stage and ask everyone who wants to continue to do so in a common area like the cafe.
- If you see a room is getting too busy, try to swap them with another bigger room that’s under capacity.
- Help the session host if they need help with the projector or audio.
- Make sure the cameras are always recording and aimed the right way. Check every session.
- Anything else that’s wrong, you are hereby authorized to step up and fix it!
Twitter 1 person
Tweeting on the Leancamp account. We want the @leancamp account to be the single source for all the Leancamp stuff happening on Twitter. Retweet ANY interesting updates on the #leancamp hashtag. (Watch out for spammers though - we’ll likely be trending!)
Updates, room changes, retweeting others on the #leancamp hashtag, answering questions.
Photographer 1 person
Action pictures and people are great. Also, please try to capture as many whiteboards and flipcharts and notes over peoples shoulder (with permission!) as possible, especially during sessions in case people want to take their stuff with them. After the event, somebody should collate and make a book out of it all. If you can, post live using tag #leancamp on Twitter and Flickr. PLEASE remember to take your cards to Central Video so they can be uploaded to our master hard drive.
Also, try to collect and save as much “collateral” as possible. All the paper and stuff that people write on should be collected so we can review or even make a book out of it too.
During Lunch
Catering 2 people
The catering people may need some extra help serving here.
Handy Templates
Ambassador Invite
The first Leancamp [City] is on [date] and we need your help, both in guidance and in getting the word out. I think there’s some potential in sharing how Lean Startup could benefit ___ and how we could apply ____ in startups. Would you have a moment to discuss this potential?
If it’s promising to you, we’d like to invite you to be a Leancamp Ambassador, to help get the word out and help us tailor the event for your community. (Not to mention discount codes!)
Leancamp is a non-profit, multi-disciplinary knowledge-sharing event loosely centered around Lean, Agile and Design-led businesses. It’s endorsed by loads of friendly, famous startup types like Eric Ries, Alex Osterwalder, and John Mullins.
We bring in businesses actually applying these approaches, so we share practical insights about what works and doesn’t. A wider range of perspectives really helps everyone learn more and progress faster.
Being an Ambassador is easy - helping get the word out on your blog/twitter/meetup group and discussing good topics so we can find the best knowledge-sharing opportunities.
Would love to hear your thoughts. Up for discussing this an afternoon/evening this week?
Host Invite
Hi ___ I’m helping bring Leancamp here to [city ]___ and thought ____ would be an ideal hosting partner.
Leancamp’s the birthplace of some significant entrepreneurial practices, and been a positive force is galvanising startup communities around the world. It’s a non-profit event supported by many thought-leaders, like Eric Ries, Alex Osterwalder, John Mullins, Brant Cooper, David Heinemeier Hansson and partners like University College London, General Assembly and The Next Web Conference. __ has a similar ethos, so might have the same benefits of hosting Leancamp.
Since we need to move fast, we’re currently reaching out to [ other hosts __], __ & ___ as well.
It would be great if we could speak to see if this is a good fit for you, and how we could benefit your students and network. I’m at ___ if you’d like to speak.
Thanks,
FAQ
How do we bring high-profile leaders to our city?
Don’t worry about the higher-profile contributors and speakers directly. Taking care that the existing local and regional contributors are meeting others with similar value and experience will create strong bonds into your community. The big names will hear about this through their trusted network (including many of the Leancamp Leaders) and then will be more inclined to come next time. Why? Because they want to give back, but they want to give back to local leaders who can multiply their value, and since they’re so busy, they go where you can promise to introduce them to people they want in their network.
What about sponsors?
Leancamp is for us by us. One of our biggest steps in an effort to make organising easier was to simply say no to sponsorship money. This revealed a better alternative - that if sponsors wanted to actually contribute rather than simply buying access to our audience, they would still help out! Our no sponsor policy not only helped reduce our workloads, it acted as a natural filter to select genuinely aligned people and organisations to take part.
A few examples of how would-be sponsors can help instead:
- Buy tickets! If we’re not hitting our sales targets, organisations can buy tickets to give away.
- Send their talented people to share and run sessions. Turn them into ambassadors and they get the benefit of sponsoring without the cost!
- Promote us! By becoming ambassadors and promoting us, they get the association in a more genuine way.
Can my organisation get credit if they aren’t hosting?
Like with sponsors, the best way for any organisation to benefit from Leancamp is through it’s people. We encourage people to represent their organisations, so as Organisers, you’re welcome to bang your own drum! Leancamp is also up for cross-proomotion.
However, we need to stay consistent to the values that brought us here, so as organisers, we are emphasising our relationship with you as people first. Opening the door to more logos or bending the rules in other ways can have a negative effect - both in alienating others in the local community who might want to contribute, and also costing time by managing expectations of would-be sponsors.
The same is true for you as it is with others who want to sponsor. The best way to gain exposure and good-will for your organisation is to lead as individuals, and point to your organisation in your Leancamp website profiles, sessions and verbally when you’re on stage.
Should we partner with conferences?
Conferences are great hosts for Leancamp. We’ve done deals with TNW Conference and Pirate Summit where they offered to cover our downside risk by covering our costs if we didn’t hit enough ticket sales. In exchange, they could send everyone in their conference to Leancamp for free.
This works quite well because:
- We can hit 60 participants quite easily, which is a solid number for satisfaction scores.
- We don’t have to worry about a lot of the venue logistics.
- We can invite their speakers to be participants and ambassadors.
- We can offer a much lower ticket prices for people who aren’t attending the conference.
What about people who sell stuff?
Leancamp is about entrepreneurship, so if people are trying to make money, that’s great! Leancamp is a great channel for selling information products, workshops or other general forms of community engagement.
It’s up to you if you want to endorse them by placing their profile on the event page. If you feel they are misaligned, or dodgy/sleezy in any way, then you don’t have to promote them. However, they’re still welcome to propose their session like anyone else.
The judgement you should place on this is if you think what they offer is of potential value to the community. Remember, we’re acting in the best interest of our ticket-holders.
Also, you should try to be neutral in your assessment. Leancamp works because it’s a place for open discussion. Let the participants discuss what works and doesn’t for them.
How large are organizing teams usually?
1-2 main organisers. 1 Advisor 5+ ambassadors to help with promo, topics and community. Usually around 5 ambassadors are quite involved, and there’s a list of 10 or so more Ambassadors on the email list who help out when they can.
On the day: 1-2 additional Leancamp Leaders in attendance 3-6 student volunteers
More Questions?