Executives, People Leaders and Open Space

With new process and technology, new way of working comes. With Agile practices in place, some of the attributes of Agile are very common and famous. Most visible, and thus most well-known, attributes of Agile are open space, co-location of all roles, stand ups and retrospective. These characteristics of Agile have played very important role in making Agile successful especially in enterprises. Software development departments of big and old companies have benefited from Agile implementation. Although these are very important traits of Agile, these traits don’t make Agile on their own. There is more than these attributes in Agile and its implementation. Companies and their leadership always get confused by this. While creating new teams or transforming existing teams & departments, leaders often don’t involve Agile coaches or follow proper Agile transformation process. They go by either some other teams’ success or half-truth-knowledge. It has its only disadvantages, but I am not going to discuss it here. I want to discuss whether having Executives and People Leaders in open space with development teams is a good idea or not.

In a typical software development department at enterprise, cubes and office walls are coming down. Executives and people leaders have started sitting in open area by either choice or order. It’s a good refreshing change to see managers sitting right next to you and accessible. This kind of arrangement has its own advantages. When managers are sitting in same size open area that other team members are sitting, it creates flat hierarchy in the organization. They seemed more accessible with co-location and without cube walls. It’s also very easy to involve them in management decision with this co-location. Advantages are there for managers as well. Executives and people leaders sitting in open area and with teams, can get better handle on day-to-day work of teams. They can make connection with more human interaction they are going to have with team members. As it’s easier for teams to access them, it’s easier for them to access teams as well. Basically, with this flat structure, things get done quickly and more accurate.

Let’s look at some of the disadvantages. As I said, open space is one of the attributes of Agile, it’s not everything in Agile. When managers are asked to sit in open space and with team, it’s usually justified by Agile requirement and which is wrong. Agile wants all team members to sit close and in open space. Team members include everyone who is contributing to work products that finally contribute working quality software. Manager usually don’t contribute to work products directly. They are indirect influence makers  and their work cannot be tracked by Agile team board. They are also usually assigned to more than one teams. And these are the reasons they don’t participate and are not invited to Agile tasking session. Similarly, they cannot contribute to retrospectives. Having them in the same location doesn’t necessarily make them more accessible. Management meetings, vendors engagement, business travel and other managerial & executive commitments can keep them away from their desk. Having executives sitting inside team room can also make some team members nervous, at least initially and may look like an attempt to micro manage. This is also the exact reason why scribes or iteration mangers are asked to avoid eye-to-eye contact in stand ups. Agile teams can become less autonomous with constant executive presence. Many teams like to have their tasking sessions and planning meetings right in team space as opposed to conference room. But, with executives in the same space, mostly on phone, it’s difficult to achieve this with the fear of disturbing them while they are on phone and have visitors. From managers’ point of view, they may not like to talk confidential items in open area. Many people leaders are engaged on a regular basis in talking about people, which is difficult to do in the presence of same people. Same is true if you want to fill out customer satisfaction survey or performance review documents. Many tasks in leaders’ lives are individual contribution tasks where they need privacy, and it’s difficult to get when you are surrounded by teams holding their meetings. Having or wearing cap while you’re busy doesn’t usually work!

I always believe that the best strategy is to use hybrid solution. Unless you have a real space constraint, managers can have two offices – one regular office cube where they used to sit for years and other open space where all team members sit. Managers can sit inside open space around stand up times and go back to their cubes for rest of the day. And repeat this multiple times a day if required. These scheduled can be published for everyone’s knowledge. This schedule can be shared across multiple teams as well. More you are closer to work-bee, more you should and can spend time with development teams.

However fascinating it sounds like to punish executives and people leaders and strip off their cubes, it’s not always a great idea either for enterprise or for teams. It’s not one solution that fits every organization or even everyone within the same organization. So, choose your method wisely.

P.S. – ‘Executive’, ‘Manager’ and ‘People Leader’ phrases are used freely in this blog and should be considered loosely defined. Similarly, ‘team’ and ‘development team’ have similar meaning with different context.


Arrays and Hashes – II

We saw how methods relevant to particular data structure can be obtained from ruby – <object>.methods or <data_structure>.methods. 

>> ohio_cities = ["columbus", "cincinnati", "cleveland"]
=> ["columbus", "cincinnati", "cleveland"]
>> ohio_cities.methods
=> [:inspect, :to_s, :to_a, :to_ary, :frozen?, :==, :eql?, :hash, :[], :[]=, :at, :fetch, :first, :last, :concat, :<<, :push, :pop, :shift, :unshift, :insert, :each, :each_index, :reverse_each, :length, :size, :empty?, :find_index, :index, :rindex, :join, :reverse, :reverse!, :rotate, :rotate!, :sort, :sort!, :sort_by!, :collect, :collect!, :map, :map!, :select, :select!, :keep_if, :values_at, :delete, :delete_at, :delete_if, :reject, :reject!, :zip, :transpose, :replace, :clear, :fill, :include?, :<=>, :slice, :slice!, :assoc, :rassoc, :+, :*, :-, :&, :|, :uniq, :uniq!, :compact, :compact!, :flatten, :flatten!, :count, :shuffle!, :shuffle, :sample, :cycle, :permutation, :combination, :repeated_permutation, :repeated_combination, :product, :take, :take_while, :drop, :drop_while, :bsearch, :pack, :entries, :sort_by, :grep, :find, :detect, :find_all, :flat_map, :collect_concat, :inject, :reduce, :partition, :group_by, :all?, :any?, :one?, :none?, :min, :max, :minmax, :min_by, :max_by, :minmax_by, :member?, :each_with_index, :each_entry, :each_slice, :each_cons, :each_with_object, :chunk, :slice_before, :lazy, :nil?, :===, :=~, :!~, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]
>> Array.methods
=> [:[], :try_convert, :allocate, :new, :superclass, :freeze, :===, :==, :<=>, :<, :<=, :>, :>=, :to_s, :inspect, :included_modules, :include?, :name, :ancestors, :instance_methods, :public_instance_methods, :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?, :const_missing, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set, :class_variable_defined?, :public_constant, :private_constant, :module_exec, :class_exec, :module_eval, :class_eval, :method_defined?, :public_method_defined?, :private_method_defined?, :protected_method_defined?, :public_class_method, :private_class_method, :autoload, :autoload?, :instance_method, :public_instance_method, :nil?, :=~, :!~, :eql?, :hash, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :frozen?, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

Let’s see some of the methods to remove or change members in an array. Method named pop works in an opposite way to push method. It removes last member from an array. So, if I use ohio_cities.pop, “cleveland” will be removed from this array and it’ll have only two members remaining with it.

>> ohio_cities #output ohio_cities array
=> ["columbus", "cincinnati", "cleveland"]
>> ohio_cities.pop
=> "cleveland"
>> ohio_cities #ohio_cities array after pop method usage
=> ["columbus", "cincinnati"]

Similarly, shift method is a complimentary to unshift method we learned before. It removes first member from an array. Companion of insert method is delete_at method. It takes index value of a member that you want to get rid of in an array.

Some other methods that can come handy to you are –

>> fruits = ["apple", "orange", "papaya", "banana", "peach", "plum", "apricot", "pineapple"]
=> ["apple", "orange", "papaya", "banana", "peach", "plum", "apricot", "pineapple"]
>> fruits.delete("orange")
=> "orange"
>> fruits #fruits array after deleting orange
=> ["apple", "papaya", "banana", "peach", "plum", "apricot", "pineapple"]

>> fruits.reverse
=> ["pineapple", "apricot", "plum", "peach", "banana", "papaya", "apple"]

If you have looked carefully to methods applicable to an array, you’ll see two methods that may look similar – reverse and reverse! – while both of these methods reverse array members, one without exclamation mark doesn’t modify an original array & one with “!” modifies original array. So, after using fruits.reverse, if you look at fruits array, it’s still the same

>> fruits
=> ["apple", "papaya", "banana", "peach", "plum", "apricot", "pineapple"]

… and if you used reverse!, fruits array is reversed permanently.

>> fruits.reverse!
=> ["pineapple", "apricot", "plum", "peach", "banana", "papaya", "apple"]
>> fruits
=> ["pineapple", "apricot", "plum", "peach", "banana", "papaya", "apple"]

This is true for all the methods with “!”, they change associated object for good. Exclamation is ruby’s way of telling you to use these methods with caution.

>> fruits.sort
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum"]
>> fruits #original array remains unchanged
=> ["pineapple", "apricot", "plum", "peach", "banana", "papaya", "apple"]
>> fruits.sort!
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum"]
>> fruits #original array gets changed (sorted)
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum"]

>> fruits.empty?
=> false

Observe the question mark at the end of the method empty? Ruby has many methods that ends with ? These methods have return type of Boolean. It’s like asking a question to ruby, very intuitive! Here we are asking if fruits array is empty? and ruby replies back loud and clear – NO!

Similarly, let’s ask ruby if banana and mango are included in fruits array or not.

>> fruits.include?("banana")
=> true
>> fruits.include?("mango")
=> false

>> fruits.first #first member of an array
=> "apple"
>> fruits.last #last member of an array
=> "plum"
>> fruits.length #number of elements of an array
=> 7

>> fruits + ["mango"] #adds two arrays to generate third array
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum", "mango"]
>> fruits #fruits array remains unchanged
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum"]

>> fruits.concat(["mango"]) #adds second array to itself (modifies itself)
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum", "mango"]
>> fruits #fruits array has mango now
=> ["apple", "apricot", "banana", "papaya", "peach", "pineapple", "plum", "mango"]

>> [1, 2, 3] == [1, 2, 3] #two same arrays
=> true
>> [1, 2, 3] == [4, 5, 6] #two arrays with same length but different members
=> false
>> [1, 2, 3] == [1, 2, 3, 4] #two arrays with different length
=> false
>> [1, 2, 3] == ["a", "b", "c"] #two arrays with different members
=> false

>> odd = [1, 3, 5, 7, 9, 11]
=> [1, 3, 5, 7, 9, 11]
>> odd.slice(3) #member with index 3
=> 7
>> odd.slice(2, 3) #3 members starting at index 2
=> [5, 7, 9]
>> odd.slice(1..4) #members with index value between 1 and 4, including 1 and 4
=> [3, 5, 7, 9]
>> odd.slice(1...4) #members with index value between 1 and 4, including 1 but not 4
=> [3, 5, 7]

Similarly, another version of slice is slice!, which modifies the original array. There is no explicit reason to use slice method, you can access element by just referring its index value.

>> odd[1...4]
=> [3, 5, 7]
>> odd[1..4]
=> [3, 5, 7, 9]

Here interesting thing to learn is how negative index works with arrays in ruby. Just like first member of an array has index value of 0 and all subsequent members have progressing index values, last member of an array has index value of -1 and negative indices count backwards from the end of an array.

>> odd[-1]
=> 11
>> odd[-4]
=> 5
>> odd[-2..-2]
=> [9]
>> odd[-5..-2]
=> [3, 5, 7, 9]

There are a few array methods that aren’t widely used or not useful in routine programming, but provides powerful influence over a given array. The are some projects where they are actually broadly used. Some of these methods are –

zip, compact, collect, map, uniq, count, <=>, each, inspect

What? You didn’t find any example or explanation of what these methods are? Well, that’s your ‘end of the chapter exercise’! Good Luck!

Arrays and Hashes

So, I taught Arrays and Hashes on last Saturday on June 15, 2013 in ATDD class. This class really went well and it’s nice to see everyone progression in their journey of ATDD.

Ruby’s documentation on Array is at http://ruby-doc.org/core-2.0/Array.html and if you’re looking for documentation in prior versions of Ruby you can find them at – Ruby 1.9.3 (http://www.ruby-doc.org/core-1.9.3/Array.html) and Ruby 1.8.7 (http://ruby-doc.org/core-1.8.7/Array.html)

Arrays in ruby are similar to arrays in other programming languages that you might already know. It has some uniqueness like negative index, multiple data types inside a single array etc. We will learn about it in detail. I first learned arrays in C programming language and since then I never have to learn arrays again. Any programming language I go to, I’ll take on its syntax to create and use arrays and I am done. In ruby, like everything, syntax related to arrays is fairly simple and intuitive. Let’s see how to create arrays in ruby.

In its simplest form, array can be created by listing its members inside square bracket (also called literal constructors). So, an array named numbers with numbers from 1 to 5 can be created by

numbers = [1, 2, 3, 4, 5]

Similarly, an array of months can be created by

months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]

If you’re very much attached to C like me, you’ll notice something very quickly. I didn’t declare data type for these arrays I created. I didn’t say what time of data types these arrays will be containing. I just created an array named months and added all members as strings and ruby just followed my order & didn’t complain at all. I think you know where I am going with this now. As you don’t tell ruby which types of members you want in an array, you can probably include different types of members in a single array. Let’s try doing it and see what happens.

>> hundreds = [100, 100.0, "hundred"]
hundreds = [100, 100.0, "hundred"]
=> [100, 100.0, "hundred"]

Alright, ruby didn’t mind when we included an integer, a floating number and a string inside a single array. Cool! You can include arrays and hashes as members of an array and ruby is cool with it.

You can add keyword Array in front of square bracket and it has the same meaning as far as array declaration is concerned.

>> numbers = Array[1, 2, 3, 4, 5]
numbers = Array[1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]

If simplicity is not your type or you like to use new in every line of declaration, you can go not-so-intuitive way of creating arrays. You can create array my using in-built Array class and initialize it with new.

>> numbers = Array.new(5)
numbers = Array.new(5)
=> [nil, nil, nil, nil, nil]

This has created an array named numbers with 5 members and all members are nil right now. We can assign value to the first member of this array by

>> numbers[0] = 1
numbers[0] = 1
=> 1

Now, if you want to create an array with some default value,

>> ones = Array.new(5, 1)
ones = Array.new(5, 1)
=> [1, 1, 1, 1, 1]

this creates an array named numbers with 5 members and all members are 1.

With all the flexibility ruby provides, it also allows you to add members to arrays without re-sizing. You can add members to an array by using either push or <<. Let’s see an example –

>> programming = ["pascal", "c", "c++", "java"]
programming = ["pascal", "c", "c++", "java"]
=> ["pascal", "c", "c++", "java"]
>> programming.push("ruby")
=> ["pascal", "c", "c++", "java", "ruby"]

Newest string member “ruby” has been added, actually appended, to array named programming. Let’s add “python” to it now.

>> programming<<"python"
=> ["pascal", "c", "c++", "java", "ruby", "python"]

Now, if you learned BASIC before pascal, you would like to add it to this array at the beginning. You can do it by unshift.

>> programming.unshift("BASIC")
=> ["BASIC", "pascal", "c", "c++", "java", "ruby", "python"]

You can add multiple members with push, << and unshift.

>> ones = ["one", "uno"]
ones = ["one", "uno"]
=> ["one", "uno"]
>> ones<<"un"<<"une"
=> ["one", "uno", "un", "une"]

>> ones.push("unus", "um")
ones.push("unus", "um")
=> ["one", "uno", "un", "une", "unus", "um"]

>> ones.push("eins").push("un")
=> ["one", "uno", "un", "une", "unus", "um", "eins", "un"]

>> ones.unshift("ena", "ek")
ones.unshift("ena", "ek")
=> ["ena", "ek", "one", "uno", "un", "une", "unus", "um", "eins", "un"]

How about adding members in the middle of an array or to some other position than first and last? You can do it with array.insert(position_where_insert_is_made, value_to_be_inserted).

>> prime = [7, 11, 13, 17, 31, 37]
prime = [7, 11, 13, 17, 31, 37]
=> [7, 11, 13, 17, 31, 37]
>> prime.insert(4, 19)
prime.insert(4, 19)
=> [7, 11, 13, 17, 19, 31, 37]

Essentially the best way to learn ruby is to try .methods to all the data types you know. So, if we have try prime.methods, we’ll get all the methods that can be applied on arrays. And then try to use some of the methods to get real hands-on pleasure in ruby.

>> prime.methods
=> [:inspect, :to_s, :to_a, :to_ary, :frozen?, :==, :eql?, :hash, :[], :[]=, :at, :fetch, :first, :last, :concat, :<<, :push, :pop, :shift, :unshift, :insert, :each, :each_index, :reverse_each, :length, :size, :empty?, :find_index, :index, :rindex, :join, :reverse, :reverse!, :rotate, :rotate!, :sort, :sort!, :sort_by!, :collect, :collect!, :map, :map!, :select, :select!, :keep_if, :values_at, :delete, :delete_at, :delete_if, :reject, :reject!, :zip, :transpose, :replace, :clear, :fill, :include?, :<=>, :slice, :slice!, :assoc, :rassoc, :+, :*, :-, :&, :|, :uniq, :uniq!, :compact, :compact!, :flatten, :flatten!, :count, :shuffle!, :shuffle, :sample, :cycle, :permutation, :combination, :repeated_permutation, :repeated_combination, :product, :take, :take_while, :drop, :drop_while, :bsearch, :pack, :entries, :sort_by, :grep, :find, :detect, :find_all, :flat_map, :collect_concat, :inject, :reduce, :partition, :group_by, :all?, :any?, :one?, :none?, :min, :max, :minmax, :min_by, :max_by, :minmax_by, :member?, :each_with_index, :each_entry, :each_slice, :each_cons, :each_with_object, :chunk, :slice_before, :lazy, :nil?, :===, :=~, :!~, :class, :singleton_class, :clone, :dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, :extend, :display, :method, :public_method, :define_singleton_method, :object_id, :to_enum, :enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

If you look at this list, you’ll find that we have already worked on some of these methods listed here.

Hope you have got off to a good start on arrays. More on arrays and then hashes soon!

Photos of notes from last few classes

I am late in posting, but here are the photos from last few classes. I am sure you are taking notes, but sometimes visuals do help.

03 272013 - Notes on White Board

03 272013 – Notes on White Board

03 21 2013 - Notes on White Board

03 21 2013 – Notes on White Board

03 19 2013 - Notes on White Board

03 19 2013 – Notes on White Board

03 27 2013 - Notes on White Board

03 27 2013 – Notes on White Board

03 12 2013 - Notes on White Board

03 12 2013 – Notes on White Board

Installation Instructions for class on 4/4/13

So, all of you must have installed RubyMine and JRuby by now. If not, here is what you need to do –

Installation of RubyMine

  • Go to http://www.jetbrains.com/ruby/download/index.html
  • If you have Mac OS or Linux, select appropriate OS
  • Download latest version available there. Current version is 5.0.2
  • Just below the button that says download, you’ll see a set of instructions to install RubyMine
  • You’ll get 30 days of free trial, and that’s the reason I want you to install just a day before we really need it, which is 4/4/13, tomorrow!
  • Follow default installation and do not change default options available during installation process
  • After it’s installed, open and verify it.

Installation of JRuby

Installation of Ruby (Optional)

  • We won’t need Ruby for this class if you JRuby installed, but it’s good to have a Ruby installation available on your machine
  • Best way to install Ruby is to go to – http://rubyinstaller.org/downloads/
  • You’ll see current version available there. As of this writing, latest version is 2.0.0
  • If you’re on Windows 7 box or 64 bit Vista, use – “Ruby 2.0.0-p0
  • If you’re on 32 bit box, use – “Ruby 2.0.0-p0 (x64)
  • Installation of Ruby on Max OS X is tricky. You can do it in different ways. One way is to follow what is written at – http://rubyosx.rubyforge.org/


Third Session

Today’s presentation

ATDD_3 – Cucumber

Today we talked about Basic Structure of Cucumber. I am also attaching a photo of white board from today’s class.

03 12 2013 - Notes on White Board

Next sessions –

  • More cucumber – basic structure 
  • Cucumber on laptop – I’ll use RubyMine
  • Role Play – ATDD Case Study

You still don’t need your laptop until we’re done with Role Play.

Thanks for working on your assignments. Here is something that I would like to add.

1) Books I love

  1. On a subject of ATDD – Lean-Agile Acceptance Test-Driven Development: Better Software Through Collaboration by Ken Pugh. The only reputed book available in the market on a subject ATDD as a process perspective. Doesn’t include any coding or mumbo-jumbo or tools. Pure process read. Real-world guide to ATDD, and presents keys to developing software with testable results. This should be your first book in your journey towards ATDD mastery!
  2. On a subject of CucumberThe Cucumber Book: Behaviour-Driven Development for Testers and Developers by Matt Wynne and Aslak Hellesøy. From the creator of Cucumber. This is the book which is recommended by Cucumber’s official site (http://cukes.info/). This book contains comprehensive Cucumber information for beginning to advanced Cucumber users. You should hold off reading this book until we are done with Cucumber basic structure sessions and some part of ruby. If you’re looking for a soft copy, here is a link
  3. On a subject of CucumberCucumber and Cheese by Cheezy. Any thing coming from Cheezy is always great! In this books he explains cucumber from his perspective. It has some coding examples to follow. Only available in a soft copy format. Cheezy comes to Columbus very often to speak at various meetings and conferences. Make sure you listen to him whenever you get a chance.

I’ll keep on adding few books as and when I find them. There are some great books available in a world of  Ruby and Agile that you can read all the time. But, as far as ATDD and Cucumber are concerned, there are very limited number of books available.

2) Research on a definition of ATDD. Find out all different kind of definitions, see what other people say about ATDD. Is it the same that you learned today? Or is it different?

All of you did some research on ATDD and that’s great. We looked at Cucumber’ official site. It’s not frequently updated, but visit this site once in a while and see what you find. When you go to home page, you see those 6 tiles… compare it with what you learned in second session. Is it similar or not…?

Slides from first two classes, your assignment details and meeting information

Hello everyone…  Hope you’re enjoying getting up early on Tuesdays and Thursdays!

Here are the links to slides –

ATDD Introduction_1

ATDD Introduction_2

Your assignments to work on before we meet next week on 3/12

1) Find two books on a subject of ATDD

2) Research on a definition of ATDD. Find out all different kind of definitions, see what other people say about ATDD. Is it the same that you learned today? Or is it different?

And about Columbus ATDD Developers Group that I was talking about…

Today’s meeting URL is –


If you’re planning to attend, register there. Refer this URL for parking information. Lunch will be served. They meet first Thursday of every month. Read their blog or follow them on twitter.

Meeting Description –

Is Test Data bothering you?
Does your cucumber test suite often fail because you don’t have enough Test Data?
Is Test Data Management your biggest barrier (or not?!) in achieving efficiency in ATDD?
How are you managing Test Data in multiple environments?
Do you have a best practice to share with others on Test Data Management?
Is there a tool that you think can help teams practicing ATDD with Test Data Management?
Can you contribute to the discussion related to Test Data?

If you answered any of these questions in yes, then you should attend our meeting in March that focuses on Test Data and its management. It’s going to be a very comprehensive open discussion among ATDD enthusiasts representing diverse range of industries and organization across central Ohio region.

Come prepared with all the questions you have and answers to some of the above questions. Bring someone with you who might make this discussion even more interesting!

We are going to meet at Pillar Technology, Columbus. Lunch will be provided.

Thank you Pillar Technology for hosting us and sponsoring lunch!

Update on 3/5 – Parking Instructions

Please park in the West Lot (see diagram below or open PDF for bigger diagram)

The access code is 5923# –  the buttons need to pressed slowly and firmly as the keypad is touchy. There is a walkway under 4th street that takes you to the smith Bros main visitor parking lot.