Milwaukee Agile Meetup - Continuous Integration Panel Discussion Summary

Last week I had the pleasure of being on a panel discussion about Continuous Integration at the Milwaukee Agile Meetup. My fellow panelists were Carl Schrammel, Adam Black, Jason Duff, James Carpenter and Adam Johnson.

The discussion grew out of the group's growing interest in this area and challenges that individuals and teams attending the Meetup had expressed recently. I know several people who said they had wanted to attend, so I thought I would post a summary of the discussion.

Q: What does Continuous Integration mean to you? When were you first introduced to the concept and how did it change your perspective?
A: After the initial text book definition was given ("Continuous integration (CI) is the practice, in software engineering, of merging all developer working copies with a shared mainline several times a day." - Wikipedia), the group continued to express their take on CI.

• CI is a powerful feedback tool for both engineering as well as project management - reduces surprises due to integration and deployments and makes the ones which occur more manageable.
• The benefits of CI are best reaped via automation, but even manual CI can bring great improvement.
• CI can help build confidence in the product and the team - one always knows the state of the code at the end of the day.

The distinction between Continuous Integration and Continuous Delivery (CD) was also drawn... with Continuous Delivery being an advanced practice where a team is able to deploy changes to production with high frequency. 

Q: What tools are being used?

A: The standard list of revision repositories, build servers, testing frameworks, continuous integration servers, deployment automation were quickly run through - basically if you are interested in CI there is likely a set of tools readily available for your language/tech stack of choice. It was noticed, however, that there are software products and systems which are not necessarily easy to integrate automation or other CI tools too. Particularly these tend to be configuration based systems, or closed systems which perhaps try to manage revision control internally - preventing access or control by external ci/build/test setups. This led to the discussion that aside from tools, the other aspect of CI is the practices and behaviors. These behaviors are often harder to implement than the tools. However, if the behaviors are embraced by a team, even the most simplistic of CI tooling can become powerful. The further consensus of the panel was that it is best to start simply - implementing behaviors and supporting tooling gradually. In this way, each advancement should be lauded as a positive win in the right direction rather than disappointment at not having achieved an elusive ideal CI or CD state in one try.

Q: How to prove the value of CI to developers? to business/product owners? how soon can one expect to see value?

A: The answers to this echoed some of the previous discussion. The general feeling was to take each instance in a case-by-case basis and look for opportunities to introduce behaviors and tools pragmatically to provide greater insight into specific areas where a team may be experiencing pain. Examples: recurring bugs, painful massive code integrations, lost code, misunderstood and mis-implemented user requirements, painful coordination/integration with other systems/teams on deployment, out of sync versions of code between environments (Prod getting ahead of Dev or Test), not being able to do certain types of testing. All of these were brought up as pain points which some degree of CI could have alleviated. 

Since CI sits on the front lines of ever changing code, the positive impact of CI can be seen very quickly (as soon as one build cycle in some cases). The key is to communicate this to the parties who would most appreciate the benefit. This is where a CI server can help by providing dashboards and automated messaging, but even utilizing the low tech approach of holding stake-holder meetings before and after a CI 'event' can shed light on the benefit of the activity.

The panel agreed that in order to get the buy in to do more advanced levels of CI requires the building of trust, something familiar to Agile Coaches and leaders everywhere. However, even the most rudimentary CI practices can provide excellent data and feedback which, if communicated properly, can facilitate the building of that trust. Due to the fact that CI can generate data about the health of the deliverable every time a change is made, it can be one of the most powerful and prolific sources of data for information radiators. The trick as with all data is to mine it for the most relevant information to the message you wish to communicate.

Q: Who owns CI? Who sponsors/drives for CI?
A: The panelists seemed to generally agree that in most large project teams, there was a dedicated Operations team in charge of maintaining the CI tools (build servers, repositories, deployments and deployment automation, ci servers, etc). However, many expressed how this could lead to the negative effects of siloing. Panelists shared their experiences with teams who used various means to combat this. Rotation of members into the ops team, rotation of ops duties among teams, the use of embedded testers to serve as the bridge between dev and ops, and use of separate scrum-of-scrums to coordinate dev teams with ops.

We did not get too much into the sponsors for CI. I would suggest, as with trying to get buy in, any individuals or groups who feel they would get a benefit out of the use of CI could sponsor it. I have seen CI started as an engineering initiative and I have also seen it sponsored by Project Management and even Product Owners.

Q: Of those doing CD, has anyone automated the signoff process in tightly controlled organization/industry?
A: No one had seen full blown automated sign-off at the level of the typical product owner, upper management deployment committee. However, several had seen groups who had automated sign-off at lower levels, such as moderate UAT sign-off. This can help pave the way to make the manual sign-off at the executive level easier once trust has been established through a record of reliable test/dev/pass/sign-off cycles.

The evening flew by and that was about all we were able to get to. Prior to the discussion, David Neuman from Redpoint Technologies sent out a list of questions to the panelists that would serve to seed the discussion. I think we hit most of the items tangentially. If anyone would like to discuss them further, leave a comment or email me.

The last question on the list asked if there was one recommendation we have for successfully implementing and leveraging CI. 

Build Automated Tests. Even if you still have to trigger your builds or other steps manually, having automated test suites that you can run against your built code is one of the most powerful tools to start getting an ROI on your CI efforts. Furthermore, many of the behaviors and practices of CI which are difficult to master initially revolve around disciplines of TDD. If you have automated tests, it is easier to start to instill these disciplines in your team. As some of the other panelists and I were discussion after the meetup, automated TDD is fun... it makes coding like a game with almost instant gratification to our problem/puzzle solving efforts. Making something fun can really make developing good habits to support it easier.

Agile Martial Arts to Prevent The Project K.O.

Recently, I have been having a number of discussions with colleagues about our projects and I noticed that there was a similarity in how we were discussing using the communication and feedback tools of Agile Development with concepts of Martial Arts.

When training in martial arts, one comes to learn that one of the most powerful tools one has in dealing with an adversary is to control distance and time. One can either increase distance in order to give one more time to analyze and deal with an adversary's attack or one can reduce distance and/or time to limit your adversary's options and ability to develop an attack.

Similarly on a project, surprises are seldom a good thing. However one cannot know everything which is going to happen. Change management strategies have evolved to try to deal with this, however, traditionally these have been largely reactive... like a novice at Close distance flailing wildly to block each attack. So how do you control time/distance to problem fallout on a project? 

This is done via the use of feedback loops of varying frequency. Feedback loops of lower frequency can give you the time to "step back" and assess changes before rushing in. This can called a Distance/Time giving action since they give you more time to assess a developing problem, but that means they may also allow the problem to develop further. Feedback loops of higher frequency allow you to address issues immediately, preventing them from ballooning into larger problems or even implementing proactive solutions to stop the problem in its tracks. These are Distance/Time takers, since they shorten the time allowed for a problem to develop. The number and roles of individuals who receive and deal with the feedback initially also plays a part in whether a technique is more giving or taking in nature. Generally, lower number of individuals whose roles are closer to the source of the problem will be a taking action, while the converse is more of a giving action.

Some Distance/Time giving techniques (lower frequency loops):

• Daily scrums/standups
• Iterative development/delivery
• Regular demos
• Regular retrospectives
• Pairing

Taking a step back to gain distance and time is one of the simplest defense moves. Appreciation of the different threat levels each distance presents and the ability to back-out to a safe distance is something which is taught to beginners. Similarly, the techniques for gaining Distance/Time in Agile Development are simple enough that any team can begin to use them right away. 

For example, a team is following a more traditional project management approach with few touch points across the team. Perhaps the PM only reports to a board  the status of things as dates for delivery of milestones occur. At this point, it is usually too late and if a problem has occurred, the PM is delivering the surprise bad-news. Even worse, a milestone is delivered only to have the product owners report all the surprise deficiencies. Obviously, both of these are uncomfortable for all involved and panic may often set in. By establishing short, frequent and regular meetings with the team including all stakeholders, a team can get the opportunity to see the problems coming and properly deal with them. They are effectively giving themselves the time to deal with the problems rather than rushing headlong into the fray. 

A recent client complained that historically, every time they tried to do a deployment the tools the development team used seemed to create surprise errors. Moreover, items were added to the new environment without the client's prior knowledge. These would not necessarily break anything, but they did add confusion and wasted time. In order to address this we established regular meetings with tech leads, the deployment lead, the clients and testing. At the meeting, proposed pending changes were discussed. A draft-deploy was reviewed for surprise dependencies which might be pulled in by the deploy tool. Team members who previously never spoke to one another now communicate regularly around a problem they were all experiencing from different perspectives. Out of this, the team has developed a much more rigorous deployment practice, surprises have been eliminated, and all parties have gained a much better understanding of their deployment tools and an appreciation for each others difficulties in deployment. It is not as much a typical Change Management/Approval board as it is an opportunity for the interested parties to communicate. Meetings never last more than half an hour and usually are about fifteen minutes, but we meet at least once a week. While not one of the traditional Agile Team Meetings, it follows the spirit of frequent cross-communication which is so vital to the Agile Approach. 


Some Distance/Time taking techniques (high frequency loops):

• Automated Testing
• Test Driven Development
• Acceptance Criteria/Tests
• Test First Development
• Pairing
• Continuous Integration
• Daily scrums/standups

Distance/Time taking techniques are usually more advanced in Martial arts as they require a bit more training and discipline to do safely. So too in software development. Most of the ones I listed here obviously employ development practices which software engineers will need to hone if they have not done them before. However, once proficiency is obtained in them, these practices can be life savers and even keep at bay the dreaded pager. Utilized well, these operate as a means of clinching problems by stopping them well before they develop into much larger problems in a more devastating environment. Use of Automated testing with a modern CI server can not only identify problems in with new code early on, it can also help make sure that once a bug is fixed, it stays fixed. One of the mantras on a team I was on was "Find a Bug, Write a Test." Basically, whenever a bug was reported, the developer wrote a test for how the solution was supposed to behave. Of course, until the bug was fixed, the test would continue to break. However, the bug would likely never resurface again since our test coverage of our code had now improved. This of course requires the developer discipline of running tests before committing, as well as a Test-First mentality. Without those disciplines the team is back to reactive flailing.

These techniques do not always stop problems from occurring, but like the clinch, they can prevent the problem from developing into a more lethal one. A team with good CI, TDD, and Acceptance testing practices for instance, can deal with and minimize the impact of major architectural changes or even severe problems introduced by changes in third-party software. They can tackle the severe problem in manageable chunks at a level of relative safety. 

I listed daily scrums and pairing under both because depending upon the situation these techniques can act both to give time to deal with potentially developing problems as well as to stop problems from starting in the first place through open communication. The latter is usually the case where someone either states what they are working on or having difficulty with and someone else on the team either gives them a solution or can help them avoid pitfalls they have experienced before. As it happens at such a frequent schedule, the time for problems to develop is often completely eliminated - effectively clinching the problems. Scrums and Pairing as time gaining operate in the sense that by approaching problems as a team tends to prevent us from making rash decisions.

A final note: you will notice that I do not say Pair Programming... while I like Pair Programming, many of my colleagues have noted that pairing is a powerful tool for all team members. I have seen PM's, BA's testers, even Product Owners pair on deliverables with great results.

Do good communication skills improve your code?

What is one of the primary design flaws we see over and over in software?

Tight coupling.

I started wondering why this might be. I thought about the mental process I go through when attempting to write cohesive, decoupled code. I realized that is was very similar to the mental process I go through when composing paragraphs and sentences.

Could there be a correlation between composition skills in one's native language and their skill at designing and developing loosely coupled software solutions?

Certainly Uncle Bob Martin's book "Clean Code" suggests something of the sort. In it he approaches method writing much like telling a story. If one is better at communicating written stories, perhaps they would be better at this form of design.

UPDATE: I found this link after posting that I thought I would share: http://www.theatlantic.com/national/archive/2012/10/the-real-reason-silicon-valley-coders-write-bad-software/263377/

What do you think?

Put your Adwords fears to REST (managing lead consumption)

I just finished up a neat little project where I got to help a client streamline how they were managing the monitoring of lead consumption among their sales members and making sure that they were not overspending in a particular region at another's detriment.

The Problem: The client is using Adwords to garner leads in various states. Their sales team members are selling in multiple states. They have a third party system for distribution of leads to the team members. This system has a toggle the team members are to use to indicate whether they are actively taking leads at a given time. When this flag is on for a team member, leads are sent to them. However, many team members were failing to turn their flag off. These members where then getting leads assigned to them when they might not even be in the office. This was to the detriment of other members who then would get none. Due to the agreement to provide members leads, this meant a lot of work tracking consumption, establishing quotas and trying to modify behavior. It also meant that sometimes the Adwords budget for particular campaigns would have to be increased in order to meet the internal agreements with the sales team. The cross region nature of sales member activity also meant that it could effect campaigns in multiple regions. They were tracking all this using a spreadsheet and a lot of leg work.

The Solution: Redpoint was asked to build a small tool to automate what the lead manager was having to spend too much of his time fretting about with the spreadsheet. In a short 6 weeks from Inception to Production Deploy we came up with a system to do this. The tool ultimately consisted of a web app and a poller service. The components pulled data from various web services including the distribution tool, internal employee data services, and Adwords. Most were RESTful - hence the title of this blog. The web app gave the lead manager a dashboard to monitor individual sales member consumption of leads against an assigned limit. This contributed to the calculation of potentially available leads for a given state. Once all members selling in a state had gotten all the leads they were supposed to, all campaigns in that state would be paused for the day. If the lead manager wanted to they could then increase a particularly good sales persons limit and allow them to sell more, or refocus a sales persons lead consumption to a particular state or states. The poller service was automated by a Windows Service using Quartz.net CronTriggers to assign various pollers to maintain the list of sales team members, the states they sold in, their lead consumption, the availability pool, and ultimately to pause or restart the Adwords campaigns appropriately.

The Result: The final tool, as it had evolved, quickly gained admiration from the executive team and the project sponsors. Even in its testing state, it had shown that it was more than just an automated valve for Adwords. The dashboards and multiple levels of control built into the solution allowed them to quickly see patterns in sales member activity and behavior. The flexibility of the Cron Triggers allowed them to schedule polls and resets as well as to automatically turn off all campaigns during down times and prevent 'greedy' team members from stock pilling all the leads while others were out of the office. This also assuaged executive fears of blowing the Adwords budget as they soon saw how this was an excellent emergency shutoff valve to control their spending.

For phase two they are already talking about the ease of creating trending and tracking data from what is being pulled as well as adding in different lead types and groupings.

As an Agilist, I appreciated this project as it had become an interesting, dynamic and interactive information radiator that would allow them to manage and change how they do business to meet the changing needs of their market and their staff.

Other Applications: Of course this sort of tool could be very useful to any growing company who is struggling to wrangle their Adwords budgets and their sales team's quotas. A similar tool could be useful to Scrum Masters, PMs or Team Leads to monitor and control story assignment within a team, by using the information from their story management system and assigning categories or even complexity sections to various members ("you did three '1 point' stories this iteration so far, you have to take a '2' or a '3' next" OR "You have been only taking stories involving that piece you created, for the rest of this iteration you need to take stories from other areas of the application"). While not so helpful with a small team, it could be very handy with a large distributed team - like the sale team in this case.

The language you code in could say a lot about your developer culture

In his essay on "Race and Language" Edward Augustus Freeman suggested that language, rather than race (genetic similarities), might be a surer indicator of cultural kinship among peoples. Professor Freeman wrote: "Every word that a man speaks is the result of a real, though doubtless unconscious, act of his free will. ... A man cannot, under any circumstances, choose his own skull; he may, under some circumstances, choose his own language. He must keep the skull which has been given him by his parents; he cannot, by any process of taking thought, determine what kind of skull he will hand on to his own children. But he may give up the use of the language which he has learned from his parents, and he may determine what language he will teach to his children." As such, the choice of language made individually and in the aggregate points to attributes of the language and those already speaking it which the new speaker of the language appreciates.

Perhaps this is why few topics among developers can start a 'religious war' faster than that of programming language.

The use of language is in essence a tool to capture an idea and communicate it to another. In IT we largely look at languages as tools to efficiently solve a problem. By 'solve' we really mean 'communicate an algorithm to the machine'. Just as some spoken languages are better for communicating facts or legal concepts and others are better for poetry or philosophical abstractions, each programming language is more efficient at 'solving' some technical problems than others. One may be excellent for modeling relationships, another for solving concurrency problems.

Looking at language this way is a good pragmatic approach to choosing 'the right language for the job', but it also can subtly mask or neglect other factors in language choice. Namely, the speaker and prospective audience plays a large part in what language communication is captured and how that communication is shaped. The above take on the use of programming language measures its efficiency in processes or cycles or memory consumed. It is the run-time efficiency - or how easily the computer understands and can execute the message. However, when using high-level programming languages, that is really misleading. It is really more of a measure of how good the compiler or interpreter for a given language is at translating the solution into efficient byte-code. So, compilers and interpreters aside, the real audience to gauge the efficiency of the language used is - humans.

Looking at how we use language it seems to lie upon a continuum between communicating to a large or a small audience. On one hand we have the language of media news reports, which linguists will often point to as a general epitome of the common speech of a people. It is intended to be understandable and consumed by the largest portion of a population. Prose is also near this end of the spectrum. On the other end you may find cryptography, where the audience is narrowed to perhaps only one other person. Sonnets, slang and technical jargon are closer to this end. They use conventions and specialized vocabulary which only a smaller subset of the population would have exposure to. Obviously a particular communication can lie closer to one end or the other given both the speaker and the audience. For instance a technical treatise might use highly exclusive vocabulary, but be written utilizing the most standard academic grammar and style. This 'regulated language' ensures that the message, while directed to technical specialists, will be understandable to the widest range of that population. It could even be accessed by outsiders armed with a good dictionary. Slang, on the other hand, often develops out the needs of the speaker... Complex grammar and punctuation is boiled down sometimes to only partial words. This makes the message easier and faster to say. To achieve this, the complexities of grammar and punctuation are replaced by context. One must understand this context, often cultural, to unpack the meaning behind this terse communication. It is particularly difficult for outsiders to master, and often intentionally so.

The intended range of audience has certain temporal effects as well. A loose jargon may make it easy for a small, tight knit group to communicate efficiently. However, it will be much harder to decode the meaning years later, perhaps even by members of that same community. Formal and standardized grammars and punctuation provide a degree of staying power to a language, allowing it to be understood for generations.
On can see this in development shops where one language is the exclusive language of development. On one hand a particular language may have been chosen for its similarity to human language. This may make translating business requirements into code easier. The same language may make it extremely difficult to describe the algorithm for performing a particular calculation. With greater complexity, it makes it more likely that a mistake will be introduced. The wordiness of this complexity can also make it harder to find the mistake. It also assumes that those writing code write well in their natural language. Run-on sentences can exist in code. A run-on piece of code is recognizable by loose cohesion, which is well known to negatively impact its brittleness and maintainability.

As a developer it is important to know the ways of expressing algorithms that is most natural to the language being developed in. This is called Idiomatic Code. However, a more seasoned Lead or Architect may realize that the eventual human viewers of the code may dictate different ways of expressing the same algorithm. This may even call for a completely different language to be used. Perhaps it makes sense to write code in one language, but to write the tests against that code in another. Testing in another language is often a good way to extend the audience of code written to an otherwise smaller audience.

This also brings up the impact of language on developer culture. Code written in a language which is only understood by one group within a team can lead to a closed culture. Think of those developers who almost have a visceral reaction to coding in anything but their favorite language. This language is usually that of a closed culture. Entire myths can be constructed about the superiority of both the language and those who code in it. Ultimately, this can threaten to alienate the developers from others on their team (testers, BA's, designers) as well as the development community at large. Uncle Bob Martin touched upon this in his 2009 talk "What killed Smalltalk could kill Ruby too".

Then there is the case where the language is chosen for you. The experience in this scenario can range from mind-expanding to dehumanizing. Surely the Junior Developer can learn much from being made to code in another language, particularly if that language has been chosen by a group of seasoned veterans across an appropriate section of the team. In this case the developer may be introduced into whole new ways of communicating and problem solving. On the other hand, there is the case where the language is imposed by a corporate decision made years earlier which may have little bearing upon the way your team works today or the problems it is being asked to solve now. This is the fallacy of simply 'buying' a language as a tool among equal tools. When that happens, the choice can become less about the effectiveness of the 'tool' and more about the packaging/marketing (e.g. - IDE's, plugins, reporting tools, support plans, name recognition, third-party-apis and frameworks, etc.). In these cases, the developers may often feel as if they are being forced to use an inferior tool for what seems like an arbitrary reason.

Finding pragmatic ways to introduce other languages where appropriate can mitigate some of the negative cultural impacts and keep communication flowing. It also can make the developers 'smarter' by making them look at and 'speak' about the problem using different paradigms than they are used to. This is much the same as people who speak multiple languages. Becoming a polyglot programmer may just make you a better designer or architect as your pool of ways of looking at a problem will be larger.

What other ways does the language you code in impact your team or say something about you?

Clade Taxonomy with Solr 4.4 without getting burnt

I have recently had the opportunity to do some work with the Apache Solr search platform. It is a phenomenal tool and I am still discovering much of its power. I had the need to apply taxonomy to documents and essentially search using the taxonomy. Now, I understand that via the underlying Lucene search engine the newest versions of Solr have faceted searching and taxonomy support available, but there is also a nice open source tool called Clade which looked like it would fit the bill for working out some proof of concept ideas I had. The current version of Clade only supports Solr 3.6 out of the box. For my solution however, I was interested in utilizing the multicore support of the latest Solr version. Unfortunately, in addition to multicore support, there have been a number of other changes since Solr3.6. An added benefit is that the Solr UI has improved substantially since 3.6 so digging into the created index is now easier. Clade is also written largely in python, a language which I dive into only every other blue moon. This all led to bit of digging and as I could not find any documentation on how to get Clade working with the latest Solr version, here are the steps I took:

1. Updated the schema config so that the uniqueKey definition for doc_id included the multiValued="false" attribute 
2. Changed the solr_url in the settings.py to conform to the multicore standard (e.g.: solr_url = ‘http://localhost:8983/solr/collection1/’ for the default example install of solr) 
3. Similarly, when copying the conf files over, you have to make sure that you put them into the proper cores folder… (i.e. solr/collection1/conf NOT solr/conf) 
4. Replaced the included sunburnt with the latest sunburnt (just named the included sunburnt folder sunburntOLD and copied the new sunburnt folder in) I did this just for good measure as so much of Solr had changed and I wanted to make sure that the sunburnt I was using to interface with it was a current as possible 
5. In the Clade lib/taxonomy.py the sunburnt query in get_docs_for_category is being executed with the fields limited to just score=true… this causes a KeyError as doc_id and title are not returned. There is a note in the code to “FIX” it… this may have worked against the old versions of Solr and sunburnt as perhaps that limiting was not working properly in those versions, however, now you need to change the line to: results = query.field_limit(["doc_id", "title"], score=True).paginate(rows=10).execute() (see: the Sunburnt Docs) 
6. That brings back all three expected fields to create the desired tuple for return.

Doing the above got Clade to work the same with Solr4.4 on my Mac as I had got it working with Solr 3.6 on my Linux machine. 

One other thing I have noted with Clade: re-running the classify script on the same data appears to create dupes in the index. This is not the expected indexing behavior so I will have to look a little closer as to what Clade is doing in that script. Fortunately, just blowing away the solr data directory clears it out - but that feels a bit heavy handed.

I hope this helps someone. Now to start wiring up my Solr instance via Spring Data...

"Our team is too _____ to be Agile"

Team dynamics is a common challenge with teams new to Agile Development. This often presents itself in comments such as "Our team is too big/small/remote/unfocused/unavailable/divided to use Agile".  Teams which have not thrown in the towel and who are still earnestly struggling with this might ask questions such as:

"What is the 'right size' for an Agile team?"
"Can we use Agile Management with remote teams or remote members"
"Does an Agile team need to be co-located?"
"Do agile team members need to be 100% allocated?"
"How do you manage multiple Agile teams (with the same backlog)?"

With the exception of the last one, these are all assuming the definition of a team as being a group of people representing the various involved skills and interests necessary to produce a solution against a shared backlog.

In essence, these are really all the same problem: how to synchronize the team members effectively. Not surprisingly, the first pain point that often comes up is around the Agile ceremony focused on team synchronization: the daily Stand-up or Scrum.

How does this look in the previously mentioned scenarios:

Small team: "We (I mean 'I') know what we are (ahem... 'I am') working on, so having a stand-up feels like a waste of time."
Sometimes a team can be small enough that it really does keep itself in synch almost naturally. So maybe you don't need to have a formal daily synchronization. This is however where the other important output of a daily stand-up might need special attention: updating information radiators. Just because the core team are all in alignment, make sure that you keep any other stake holders in the loop so that they can help or give guidance/direction where needed. Some sort of regular check point is also good to make sure that you have everyone's attention in case an impediment comes up that needs to be dealt with higher up.
Advanced Tip: try synchronizing not just on tasks, but on your common goals. A short daily re-dedication to team goals or values (perhaps those noted in a retrospective) can be very powerful even for small teams which are otherwise synchronized on the work being done.


Big Team: "We have so many people involved that our stand-ups take an hour and we never really feel that we have a common direction on the work. Also, because the team is so big not everyone shows up all the time"
First, ask yourself whether all these people are really needed for the work being done in the given Sprint. If not, can their needs/interests be met by less frequent special meetings to synchronize around their particular interests? Some teams get bogged down with extra BA's, Testers and even Scrum Masters and Developers who are really there to collect information for a tangential team. While communication and integration across teams is important, they are really more like additional Customers to your team and as such, should not be involved directly with the core teams synchronization. Once synching is completed, information they need can be more appropriately communicated in a separate meeting.
If everyone at your Stand-up is really part of the Sprint work, can the project backlog be carved up and the group split into two teams? This may take a little planning and grooming as well as coordination against the program/product backlog or release plan.
Agile can be done with large numbers of people. Team size however often tends to become less efficient beyond 6-8 developers plus the rest of the team. Usually this means 1-2 of each of the following: BA, QA/Tester, Scrum Master/Team Lead. The trick is to carve up the work and coordinate the effort such that value is still being regularly delivered. This is often done around value 'themes'. If team size starts to interfere with delivery of your commitment every sprint, think about splitting up the team.
Advanced Tip: Splitting up the backlog and team is simply an organizational abstraction. Given you have decided to split the backlog into two teams for efficiency, if you hit a sprint where it makes more sense to work as one team to deliver value go ahead and recombine for that Sprint.


Team with remote/non-co-located members: "It is hard to find a time to meet. Communicating with remotes loses much of the context so stand-ups become more of a status report. Not everyone shows up regularly. Not really sure what team members are working on. We feel like we are constantly fighting for synchronization, not just at stand-up."
I include non-co-located members in this category because one can feel like a remote if one is across the building, the street, or the city. The problems can be the same. When people work in close proximity to each other, there is a lot of high-bandwidth communication which goes on around discussions about tasks being done. Much of this can be lost by team members who are too far away to hear these conversations. This dis-synchronization seems to dilate with the difference in time zones. A team with members in the same time-zone +/-1 hour may be able to make up via various communication tools such as IM, Skype, Google Hangouts, Google Docs, and remote pairing techniques. Beyond that, the difference in time zones begins to add overhead to delivery. The benefit of the remote members has to be weighed against the cost to productivity on the Project as whole. One way to counter this friction is to gather remotes into teams which are closer in time zone (ideally co-located) to each other than the main team and carve off some of the backlog just for them, similar to dealing with a too Big Team. Similar also to the Small Team, regular and frequent updating of information radiators and publishing them so that remote members can see them is crucial. If it can be partially automated (such as build status, or even Sprint burn downs/ups) all the better. This is the type of team where having a digital Story/task board or at least duplicating the Story/task board digitally may be highly beneficial. Advanced Tips:  1) If you can afford to bring the remotes "to the mothership" at least for a sprint or two in the beginning, that can help solidify the team. Some teams bring the remotes "home" at regular intervals. 2) Remote pairing is a viable technique. If you have high bandwidth internet, you can pair using tmux or google docs (depending on what you are working on) while speaking over skype or IM. Particularly for paired programming, however, you should make sure that the remotes are good at pairing in person, so they know what to adjust to when pairing remotely. An excellent presentation on pairing done right can be watched here. Joe Moore also has lots of good tips on his remote pairing blog.


Team with partially allocated members: Similar to the Team with remote members with the added "Partially allocated members are going to A LOT of daily meetings."
Sure, it is nicer to have 100% allocated teams, however, team members do not need to be 100% allocated to an Agile project for it to work. They do need to be 100% dedicated to working on the Agile project for the percent of time they are allocated. If a team has a member who is allocated 50% to a project, for 20 hours of their 40 hr week, they should be working solely on helping the team meet its Sprint commitment. This is one of the reasons I do not like assigning tasks during planning but rather prefer to just place the stories in priority order and allow the team members to pick up tasks as they finish other ones. In the partial allocation scenario this avoids someone who finishes their task early, realizing their other tasks are blocked, and then just spending their time trying to get ahead on their other project. What should happen is they should be empowered to pick up something else in the Sprint backlog to help the team deliver the value it has promised.
Another guideline I have found is that allocation beyond two projects usually lowers productivity. The scheduling of time to synchronize with the team can actually become harder with too many allocations than it is with remote members. If they are allocated across 3+ other Agile projects, think about how much time they are in meetings rather than working for any of the projects' deliverables. Furthermore, the context switching demanded on them is a huge drag on their ability to engage meaningfully.
Due to the caveats and the hidden losses of productivity, this is why many teams just decide to have 100% allocation and avoid the potentially costly headaches.
Advanced Tip: If you have a program with many projects who share many of the same resources, consider consolidating those shared resources and carving the backlog such that they are only spread across one or two projects. With two projects, someone can work in the morning on one project, go to lunch and finish the day on the other project. This is much more manageable for all involved.


Multiple teams (or remote teams) with the same backlog: Similar to the Big Team with the added "We often feel we are stepping on each others toes. We find it hard to break up/hand-off/work on stories and deliver meaningful value." Add the complexities of the Team with remote members if one or more of the teams is remote.
The difficulty here seems to come from the fact that being too closely joined around a backlog, the teams are not independent enough to self-organize and drive value. Try to carve up the backlog into functional chunks. This may be almost a sub-backlog. If the teams are working this way, then also ask whether synchronization with both teams fully present is of real value or whether each team should synchronize internally and simply report out at a separate meeting regarding integration points. This can keep the team focused on the work it has in front of it, instead of the work the other team is doing which it really cannot impact anyhow. Having good testing between these teams can provide an excellent interface or bridge.  This can allow teams to develop independent of the deliverable of the other team. When the other team completes its portion the testing framework is already there to verify the final integration. You may want to up your compliment of testers to at least one per team with possibly an additional one to facilitate cross team testing. Updated information radiators are also key to helping each team stay on top of what the other is doing without being over intrusive.
Advanced Tip: One of the dangers of carving up a backlog and using multiple teams is a siloing effect. To combat this rotation of team focus can be a powerful tool. If teams are all local, they can implement this via rotation of members. This provides a gradual change that has less impact on each teams velocity. If one or more teams are remote, this can also be done, but you will likely wish to switch the whole teams focus. In this case, you can mitigate the drag of context change by setting up a temporary exchange program. Let us say Team A is working on widgets and Team B is working on sprockets. When they switch a member of Team A continues to work as a remote pair for Team B for a Sprint or two. In this way Team B can get some of the expertise of Team A's prior work on widgets. Similarly someone from Team B would remote pair with Team A for a sprint or two sharing knowledge about sprockets. Again, well written tests also can greatly facilitate this transfer of knowledge and responsibility.