Technical Classes
Tuesday Classes - Wednesday
Classes
100 Series - 200
Series - 300 Series
- 400 Series - 500
Series
600 Series
- 700 Series
- 800 Series
- 900 Series
Tuesday, March 2, 2010
100 series
8:15 am - 9:30 am
101 - Thinking Generically in C++
Dan Saks
C++ function templates let you write generic algorithms—algorithms
that can be easily adapted to operate on different types.
Well-crafted generic functions can be remarkably flexible,
yet efficient and easy to use. But not all generic functions
are born that way, and achieving a good balance of simplicity,
generality and efficiency may involve carefully considered
tradeoffs. This session uses concrete programming examples
to illustrate how to minimize restrictions on the generality
of an algorithm and what tradeoffs to consider when such
restrictions are unavoidable.
Prerequisites: Some C++ programming experience. No knowledge
of templates is expected.
102 - Integrating WPF & WCF into Your Office
Business Applications
Tim Huckaby
This session will highlight many of the ways that the Windows
Presentation Foundation (WPF) and the Windows Communications
Foundation (WCF) can be leveraged in Office applications
built with Visual Studio Tools for the Office System (VSTO).
Visual Studio 2008 introduced an array of new features
aimed at a wide range of Office solution types. With Visual
Studio 2008, you can build solutions that incorporate the
native capabilities of the Office client applications (like
Outlook) combined with the sophisticated UI capabilities
of WPF that's connected to remote data and services via
WCF, and use the RAD features of LINQ to manipulate that
data. These new technologies provide opportunities for building
powerful solutions with functionality that was previously
difficult or impossible to achieve.
Now that Office has evolved into a true development platform,
office-based solutions are becoming increasingly sophisticated,
less document-focused and more loosely coupled. This session
will teach you how easy it is to build robust solutions
that leverage the latest technologies.
103 - Quality First: The Role of QA in Agile Teams
Robert C. Martin
eXtreme programming is an Agile software methodology that
puts a heavy emphasis on testing. In an XP project, the
role of QA changes. Tests are considered to be a form of
unambiguous documentation. One particular kind of test,
Acceptance Tests, is considered to be an unambiguous form
of requirements specification. Therefore, rather than being
back-end validators, the QA team is brought to the front
of the process to be specifiers. By writing acceptance tests,
the QA team writes the requirements that the developers
must conform to. This class provides an overview of XP,
briefly covers all its practices, and then puts a special
emphasis on the role of QA.
104 - Beyond User Stories: Finding Missing Links
in Your Product Backlog
Ellen Gottesdiener
How do Agile teams account for backlog items that do not
fit the user story paradigm? In addition to user stories,
what are ways you can represent product needs? How do you
account for nonfunctional requirements on an Agile project?
Teams struggle with how to incorporate quality attributes
(sometimes called “quality of service” requirements), external
interfaces, design and implementation constraints, and team
or technical “stories” into their backlogs. Without these
items, you will not build the right product, or build it
right.
This presentation will introduce you to ways that Agile
teams represent these nonfunctional requirements and other
items in the backlog. You’ll learn what nonfunctional requirements
are, five techniques for representing quality attributes,
two ways to identify external interfaces, how to use completion
criteria to define design and implementation constraints,
and explore ways to incorporating cross-cutting requirements.
105 - Agile Development with Entity Framework 4
Julie Lerman
Entity Framework 4.0 supports Agile development with the
ability to do model-first development, and to use POCO (Plain
Old CLR Objects) classes with Entity Framework. You can
use your own classes without having to bind them to the
Entity Framework APIs, yet still benefit from the querying,
change tracking and updates that EF provides.
One flavor of POCO is "in the box" and uses a
model. An extension to EF will also provide code-only development
that relies on configuration over convention, and you will
not even be required to build a model. This class will teach
you how to leverage these new features.
106 - Drive Requirements with Rapid Prototyping
Jim Hobart
Successful enterprise-level applications originate with
a great set of understandable requirements. Rapid Prototyping
can dramatically shorten the time required to capture and
agree upon the user interface requirements for a project.
Discover how kicking off your requirements sessions with
facilitated Rapid Prototyping will get you to the goal faster
and more successfully. In this class, you’ll learn how to
use whiteboards and rapid prototyping tools to allow visualization
of the requirements.
107 - The Role of the Architect in Software Development
JP Morgenthal
Below the surface of the IT industry, hidden away from the
eyes of the business, controversy is growing over the Architect
title and its role in software development and the Enterprise.
Since the mid-1980s, whom the title Architect is bestowed
on has been hotly contested, and it is made more difficult
by many individuals bestowing it upon themselves. How can
the software development managers, and the business, identify
and hire appropriate architectural resources in lieu of
sufficient guidelines and useless certifications? This class
will teach you some interesting and innovative solutions
to this problem.
108 - The Productive Programmer
Neal Ford
The Productive Programmer consists of two parts: mechanics
and practice. In the mechanics section, we’ll focus on four
principles of productivity: acceleration, focus, automation
and canonicality. This session defines the principles and
describes their use, but the primary focus of this class
is to present real-world examples of how you can use these
principles to make yourself a more productive programmer.
The second part of this session teaches you 10 ways to improve
your code, derived from the practices section. This class
includes tons of examples, all culled from real-world projects.
Tuesday, March 2, 2010 Back
to top
200 series
9:45 am - 11:00 am
201 - Mastering the Managed Extensibility Framework
(MEF)
Kathleen Dollard
Microsoft made a big jump into composability with the introduction
of the Managed Extensibility Framework, otherwise known
as MEF. In this talk, you’ll learn how you can leverage
MEF in the three overlapping categories of MEF-based applications:
plug-ins, ecosystems and composition-based architectures.
MEF is a tool to broker a collection of discrete parts into
a coherent set of relationships.
MEF maintains access to a library of available parts held
in catalogs. It provides these parts as requested. This
brokering, based on contracts you define, transforms applications
from a series of dependencies to a series of decoupled units,
allowing the analogy with building applications with Lego
blocks. MEF does this while remaining extensible; this class
focuses on the attributed model, but MEF is capable of supporting
other types of models such as DLR or POCO.
While composability increases the testability, flexibility
and maintainability of your application, it also introduces
a new set of challenges. It demands new thinking and presents
significant debugging challenges. Explore the power of MEF
on both the Silverlight and .NET platforms and techniques
to address the inherent challenges.
203 - Driving an Agile Peg in a CMMI Hole (Part
1)
Timothy Korson
Most corporations are still fairly traditionally structured
even though many software development teams are heading
full steam into modern, highly iterative Agile software
development techniques. This leaves management stuck coping
with an organizational and technical paradigm shift that
traditional project management practices are inadequate
to handle. Managers trying to encourage best practices as
recommended by CMMI and SPICE find themselves at odds with
developers trying to adopt best practices as recommended
by the Agile manifesto.
This class addresses practical ways for testers faced with
the formal, heavyweight process control inherent in CMMI
recommendations to still achieve many of the lighter-weight,
more flexible practices of Agile development. The goal is
to produce a pragmatic, yet productive quasi-Agile development
environment. You’ll learn:
• The characteristics of modern software development techniques
and their effect on QA activities
• How, in the context of iterative, incremental projects,
to use risk analysis to balance the need for adequate testing
and quality assurance activities on-time and within budget
• Specific techniques for the selection and construction
of test cases, and how to convert stories and use cases
into test cases
• The optimal way to organize the development and testing
teams for iterative, incremental projects
• The various testing models, patterns and tools and know
when and where it is appropriate to apply them, especially
in conjunction with the special needs of iterative software
development
• How to develop a testing strategy for an iterative, incremental
software project and devise appropriate test cases, and
allocate test resources in a manner compatible with that
strategy
• The top 10 pitfalls of testing in today's modern software
engineering environments
Prerequisites: Some experience testing at the system level
204 - Building a SOA-based Platform-as-a-Service
with .NET
JP Morgenthal
This session is based on a true story. In 2005, the speaker
built a Platform-as-a-Service for the supply-chain and logistics
industry. Seeing the complexities associated with large-scale
ERP systems and the existing legacy applications in the
space, the speaker set out to create a set of interoperable
but loosely coupled services that would enable users to
build out new supply-chain processes without having to throw
away their existing applications and systems. This session
will cover some of the real-world complexities faced during
the design and implementation. This PaaS is now responsible
for three solutions that have received industry accolades.
205 - Introduction to Backlog Grooming
Hubert Smits
Learn how the product owner/manager, the development manager/scrum
master, the architect and the development team work with
requirements. You’ll see how the complexity of your project
relates to the frequency and intensity of the preparation.
In the class, you’ll create an iteration structure that
incorporates the preparation activities into the regular
development work. You will practice breaking up large requirements
(stories) into smaller ones. Then you’ll learn how to inspect
the size of requirements, and how the size relates to the
clarity of the requirement. We will look at examples of
requirements, either written (PRD, Use Case, User Story)
or graphical (wire frames), and how these artifacts are
used within the delivery team.
206 - Security 101: An Introduction to Web Software
Security
Allen Holub
As more and more of our applications move onto the Web,
security becomes even more critical. Good security, however,
has to be built in, not tacked on as an afterthought. Misconceptions
about security (that an application can be made secure solely
by using encryption (https) and firewalls, for example)
abound. Moreover, security is more an architectural (at
both the system and program level) and process problem than
a coding problem.
This class will cover security architectures, code and
design review, penetration testing, risk analysis and risk-based
testing, security-related requirements, static analysis,
abuse cases, security operations, and crypto. Time permitting,
we'll finish up by looking at a common "exploit"
so that you can understand the sorts of things that make
an application vulnerable.
207 - Real Software Engineering
Glenn Vanderburg
"Software Engineering" as it's taught in universities
simply doesn't work. It's costly and time-consuming, and
yet doesn't significantly increase a team's ability to deliver
high-quality software. But in every other field, the term
"engineering" is reserved for practices that actually
work well.
What then, does real software engineering look like? How
can we consistently deliver high-quality systems to our
customers and employers in a timely fashion and for a reasonable
cost? In this class, we'll discuss where software engineering
went wrong, and build the case that disciplined Agile methods,
far from being "anti-engineering" (as they are
often described), actually represent the best of engineering
principles applied to the task of software development.
208 - .NET Developer's Guide to F#
Ted Neward
F# is a new programming language incorporating the most
important concepts of object-oriented and functional languages
and running on top of the CLR as standard assemblies. Sporting
the usual object-oriented concepts like classes and inheritance,
F# also offers a number of powerful functional features,
such as algebraic data types, immutable objects by default,
pattern matching, closures, anonymous functions and currying,
and more. Combined with some deep support for the CLR and
.NET class libraries, F# offers .NET programmers an opportunity
to write powerful programs with concise syntax for a new
decade of .NET programming.
In this class, you’ll learn about the parts of F# that
feel comfortable to the traditional object-oriented developer
and the various ways that F# improves the object-oriented
experience. Then we’ll cover the parts of F# that are functional
in nature (rather than object-oriented), and study things
like currying, partial function application, writing generic
functional code, and some of the functional design approaches
that can make coding easier.
Tuesday, March 2, 2010 Back
to top
300 series
11:15 am - 12:30 pm
301 - Implementing Secure Login
Allen Holub
Secure login is a particularly tricky bit of coding, particularly
if you want to log in from a page that was served using
http rather than https. This session looks at two ways to
solve that problem: a "pure" secure login that
uses https to communicate with the server, and a less-secure
"double hashing" method that is adequate for situations
where login is used for customization of http pages rather
than to protect submitted form data (and doesn't require
https or a certificate). The class teaches both the underlying
theory as well as implementation. The examples use JavaScript
for client-side code and Java Servlets on the sever side.
302 - Make Your Builds More Groovy
Paul King
The bane of many developers' lives is their build scripts.
They find them hard to write, hard to understand later,
and each project seems to do things in vastly different
ways and they take forever to run—if they successfully run
at all. This class looks at the available technologies to
ease the burden of writing build files with a particular
focus on technologies that support the Groovy programming
language. We’ll cover:
The “build your own” approach, including process and parallelization
features using Ant from Groovy; using Groovy from Ant; using
Ivy; using Gant; using Maven and GMaven; using Graven; using
Gradle; continuous integration server hooks; and deployment
management.
While these options leverage the Groovy language, they
are by no means solely for building projects that make heavy
use of Groovy directly. All of these technologies are very
much applicable to Java only as well as polyglot projects.
A brief look at non-Groovy alternatives will also be covered.
As we discuss each technology (some would argue that some
of the options we have for writing builds actually can make
our lives worse!), we’ll try to look at the pros and cons
and best practices.
303 - Driving an Agile Peg in a CMMI Hole (Part
2)
Timothy Korson
See description for course #203.
304 - Principles of Test Driven Development
Robert C. Martin
Testing is not a verification technique. Testing is a design,
documentation and specification technique that incidentally
verifies that the software works as intended. This class
discusses and demonstrates the disciplines and techniques
of Test-Driven Development (TDD). Demonstrations are in
Java using the JUnit and FITNESSE frameworks for Unit testing
and Acceptance testing, respectively.
305 - Developer's Guide to iPhone Development
Ted Neward
With the recent resurgence of Apple's hardware platforms
and the popularity of the iPhone and Apple App Store as
a mobile computing platform and delivery vehicle, developing
for the iPhone has suddenly become the "new hotness."
In this class, you’ll learn the basics of iPhone development,
from the perspective of developers who've been writing code
for other managed platforms (Java, .NET). We'll talk about
the tools, the languages (Objective-C and Nu), the simulator,
and more, as well as show how to deploy an application to
the simulator that comes with Apple’s Xcode IDE, and to
the iPhone itself.
306 - Quarks, Protons and Molecules: Principles
Behind the Patterns
Ken Pugh
Object-oriented design patterns embody numerous design principles
that are found in programming. This class dissects patterns
into these principles and explores the relationships between
the patterns based on them. Quarks represent the axioms;
protons are the objects constructed from the quarks; and
molecules are the patterns. For example, indirection is
a principle that is used to construct objects that employ
delegation that is used in the Strategy pattern. You’ll
use your own knowledge of the principles to better understand
the patterns and to help adapt the patterns to their own
application.
307 - Designing Enterprise Mobile Applications
Jim Hobart
The world is going mobile! As the mobile user experience
evolves into a highly visual rather than audible experience,
you’ll want to learn new techniques to create a seamless
user interface between classic phone interactions and the
new visual interactions made possible on the latest mobile
phone and PDA platforms. This class will explore new task
interaction models and evaluate the latest findings with
AUIs (Attention User Interfaces). The session will also
cover how to successfully deploy existing applications on
a mobile platform.
308 - Entity Framework 4 and WCF — So Happy Together
Julie Lerman
The first version of Entity Framework proved challenging,
to say the least, when it came to working across processes.
Many of us had to dig very deeply into EF to come up with
patterns to make it possible to write usable WCF Services
leveraging an Entity Data Model. The new version of Entity
Framework offers a number of improvements along the lines
of simple methods that will allow us to better work with
disconnected, related entities. Additionally, there will
be a number of new patterns supported in the Entity Framework
such as POCO (Plain Old CLR Objects), self-tracking entities
and direct support for Foreign Keys. We'll take a look at
these improvements and see how they simplify the task of
building and consuming WCF Services with Entity Framework.
Tuesday, March 2, 2010 Back
to top
400 series
1:30 pm - 2:45 pm
401 - The STL from the Outside In (Part 1)
Dan Saks
This tutorial covers selected intermediate and advanced
features of C++ templates and the Standard Template Library
(STL). It begins with a brief review of templates and the
standard containers and iterator categories, and goes on
to cover functional classes, functional adapters, and iterator
adaptors. It explains how various STL components communicate
with each other through nested types and traits classes.
The goal is to provide insights that will help you use the
STL more effectively, as well as equip you to extend the
STL with new algorithms and containers that will work properly
with the standard components.
Prerequisite: Attendees should have prior C++ programming
experience. Experience with templates would be helpful,
but not essential. The speaker recommends the class “Thinking
Generically in C++” as a prerequisite to this session.
402 - Groovy from the Trenches
Andrew Glover
Groovy has been successfully leveraged at various companies
around the world in order to build enterprise applications
on the Java platform quickly. In particular, Groovy has
proved its value at a large financial services client on
more than one occasion to build mission critical applications
in short order, all while leveraging their existing investment
in the Java platform from developer tools all they way to
data center management.
From exposing legacy data models via RESTful Web services,
to mission-critical reporting applications built with GroovySQL
and Spring, to Groovy's core language features and much,
much more, I'll show you tips and tricks that separate Groovy
from the pack and expose how one can quickly build real
world applications that meet a business's needs quickly
with fewer lines of code.
403 - Make the Most of your Testing Time in the
Java Virtual Machine
Andres Almiray
The Java platform ecosystem harbors many languages besides
Java. In that vast set of languages there is one that has
received the title of “Next-Generation Java,” but not because
it dismisses Java, not at all! It is because it embraces
the language and extends it in a friendly and fluent way.
That language is Groovy. Testing Java code can be cumbersome,
especially when rigid limits as verbose syntax and static
typing get in the way. Groovy can help you write less code
while retaining the same behavior. It can also test your
Java production code without any special bridge between
languages. Groovy integrates seamlessly with all Java libraries,
testing frameworks and IDEs, which means you won’t be throwing
away your Java knowledge, you’ll just make it groovier.
You’ll learn how to use Groovy to aid Java tests in key
areas as code verbosity, mocking, XML production/consumption,
and behavior-driven development.
Prerequisites: Attendees should have good knowledge of
the Java language and common testing frameworks like JUnit
and TestNG, and be proficient in one of the major Java IDEs
(IDEA, NetBeans, Eclipse), as well in Apache Ant or Maven.
Laptops loaded with the latest stable groovy distribution
can be found at groovy.codehaus.org/Download
404 - Collaboration Works! Facilitation Skills
for Agile Teams (Part 1)
Ellen Gottesdiener
Collaboration happens when all members of a group or team
share a common purpose, enjoy mutual trust, and use agreed-upon
approaches for their work. A well-tuned team operates like
a jazz ensemble: multiple instruments playing a single theme
inventively, generously and skillfully. This kind of teamwork
doesn’t just happen. Teams don’t just form and jell automatically.
How, then, can team members encourage real collaboration?
This experience-based workshop teaches effective facilitation
skills and collaboration patterns that help Agile teams
collaborate better. Participants will learn how to recognize,
reward and exploit collaboration to enhance the quality
and efficiency of their development efforts. We’ll explore
traditional (competitive) vs. collaborative team differences,
group norms, effective decision making, working with walls,
and effectively handling conflict and “difficult” behavior
from your members. You’ll learn how to integrate healthy
collaboration into Agile practices, such as team chartering,
iteration planning and retrospectives. Attendees will also
receive a rich set of materials describing specific techniques
to promote collaboration.
405 - Agile Release Planning (Part 1)
Hubert Smits
In this class, you’ll practice a release-planning session,
the single most overlooked practice in Scrum. Scrum talks
about a Vision and a Product Backlog, but how to predict
an end-date from a product backlog is a well-kept secret.
This session will inspect a product backlog and determine
the necessary detail for a good backlog. You’ll practice
the planning component and predict an end date for their
practice project. We'll then inspect how to calibrate this
end date during the execution of the project, how change
impacts the end date, and how a product manager can guard
and guarantee an end date.
406 - Extending Virtualization Deep into the Development
Life Cycle
Andrew Binstock
Many developers still view virtualization primarily as a
means of testing the portability of code. This view greatly
undervalues the benefits that virtualization can deliver
to organizations that integrate it into their development
life cycle. In this session, you will learn how virtualization
can be leveraged very effectively for development, validation,
integration testing and user acceptance testing. You’ll
also see how virtualization can boost your efforts around
development security, especially if your team uses offshore
or contract developers. In addition, virtualization's benefits
in demonstrations and in user training will be explored,
if time permits.
You will come away with numerous new ideas for leveraging
the technology in the dev cycle in ways that bring immediate
and clear benefits. This is a class filled with pragmatic
actions that can be taken without disrupting existing dev
practices and policies. It is also technology-neutral: Anything
suggested can be done with any of the mainstream virtualization
platforms available today.
407 - Evolutionary Architecture & Emergent
Design
Neal Ford
Most of the software world has realized that BDUF (Big Design
Up Front) doesn't work well in software. But lots of developers
struggle with this notion when it applies to architecture
and design. Surely you can't just start coding, right? You
need some level of understanding before you can start work.
This session describes the current thinking about emergent
design and evolutionary architecture, including both proactive
(test-driven development) and reactive (refactoring, composed
method) approaches to discovering design.
The goal of this session is to teach you nomenclature,
strategies and techniques for allowing design to emerge
from projects as they proceed, keeping your code in sync
with the problem domain.
Prerequisites: A knowledge of general software architecture
and design issues
408 - Software + Database Archeology (Part 1)
David Intersimone
Software + Database Archeology is a process for approaching
unknown software and databases. It’s an approach to unraveling
the complexities of an existing application. It is a six-step
method you can use to evaluating frameworks, component libraries
and databases. And you can use it to analyze past systems
to learn from and to understand how there were built.
What can be learned from Software + Database Archeology?
• A high-level architectural understanding
• Weak points in existing software — maintenance nightmares,
performance bottlenecks, possible security holes, and compliance
issues
• Standards compliance, or lack thereof
• The overall health and value of the application and database
• Architectural approaches, or how not to solve a problem
• Finding and harvesting algorithms and patterns
• Creating logical models from physical models
• Giving you a head start on the next phase of development
of the system
While you can perform Software + Database Archeology by
hand using traditional inspection, reviews, reading code
and other techniques, this class will show you how to use
tools to perform Software + Database Archeology.
Tuesday, March 2, 2010 Back
to top
500 series
3:30 pm - 4:45 pm
501 - The STL from the Outside In (Part 2)
Dan Saks
See description for course #401.
502 - Make Your Tests More Groovy
Paul King
Testing can be a complex and thankless task. The technologies
change so fast that your tools don't work as they should
or you have to write lots of low-level boilerplate code
that is obsolete almost as soon as it's written. Your tests
are brittle and hard to relate to customer requirements.
You aren't even sure that you are testing the right things.
Let's explore some techniques and tools for easing some
of these burdens and try to move testing from tedious and
hard to easier and fun!
In this class, you’ll sample a flavor of many techniques
and tools, and cover these topics:
• Using easyb for BDD-flavored acceptance tests
• Developer testing using JUnit 4, TestNG, Instinct, Spock
and GMock
• Writing domain specific testing languages (testing DSLs)
• Testing Web applications with WebTest, Tellurium, Selenium
and WebDriver
• Testing RESTful and SOAP-flavored Web services
• Testing databases with DbUnit
• Testing rich clients and GUIs with FEST
• Performance testing with JMeter
• Model-driven testing
Many of the examples will use the Groovy language, but
the lessons apply to Ruby, .NET, and other languages and
scenarios.
503 - Craftsmanship and Ethics for Professional
Software Developers
Robert C. Martin
What does it mean to be a professional software developer?
What rules do we follow? What attitudes do we hold? And
how can we maintain our professionalism in the face of schedule
pressure? In this class, you’ll learn about the practices
used by software craftsmen to maintain their professional
ethics, resolving the dilemma of speed vs. quality, and
mess vs. schedule. You’ll get a set of principles and simple
Dos and Don’ts for teams who want to be counted as professional
craftsmen.
504 - Collaboration Works! Facilitation Skills
for Agile Teams (Part 2)
Ellen Gottesdiener
Please see description for course #404.
505 - Agile Release Planning (Part 2)
Hubert Smits
Please see description for course #405.
506 - Design Patterns in the Real World
Allen Holub
Most books on design patterns present each pattern in splendid
isolation, as if your program contained only a single pattern.
In the real world, patterns overlap one another and interact
in complex ways. This class takes a unique approach to teaching
patterns by analyzing a real computer program in terms of
the patterns used to implement it.
We'll look at how the design patterns are actually used
in practice, and see how the strengths and weaknesses of
the patterns play off one another. You'll also get a chance
to see how real-world realizations of the patterns can differ
from the Gang-of-Four examples, and how a given pattern
can be implemented in various ways.
Prerequisites: The examples are in Java, but C++ and C#
programmers should have no problem following along. Some
familiarity with the Gang-of-Four patterns is assumed, however.
(You should, at minimum, be able to identify them by name.)
507 - Managing Global and Distributed Teams
Ken Pugh
Miscommunications, misunderstandings and interpersonal conflict
thrive in the typical environment of the distributed team.
Distributed teams, and especially global teams, are more
likely to face these issues because of time-zone offsets
and differences in organizational culture. Global teams
are not only more geographically dispersed than domestic
distributed teams, but they're also separated by language,
culture and a large number of time zones.
In this class, we'll inventory the challenges faced by
distributed teams and global teams, with special emphasis
on the problems of managing outsourced elements, both domestic
and offshore. You’ll get tools for anticipating and addressing
the challenges managers face, and suggest ways to deal with
crises that develop when global or distributed teams run
into trouble. You’ll have the opportunity to participate
in several interactive exercises to experience both in-sync
and out-of-sync communication.
508 - Software + Database Archeology (Part 2)
David Intersimone
Please see description for course #408.
Back
to top
