|
|
An Introduction to .NET
and the .NET Framework. Confused by all the .NET hype? Wondering how .NET
will change the way you develop and work tomorrow? Or just wondering what an elephant
has to do with it? We will explore a UML model of the .NET Framework, the core services
in the new object-oriented .NET API. .NET provides a vast sweep of new reusable services, covering everything from window processing to Internet applications and
beyond. In fact, the .NET Framework is so large that it's easy to miss the forest
for the trees. Each .NET expert enthuses about the features that he or she finds
most interesting; so as you listen to different experts, you may get a very disjoint,
confusing, or even conflicting picture of what .NET is all about. We will take an
exploratory journey through the .NET forest, showing you some of the more interesting
sights you might otherwise have missed. Learn what .NET is all about from the inside,
so you can better evaluate the hype and see how .NET can help you. And as for the
elephant? Check out this poem.
Just substitute ".NET" for "elephant"...
Audience: Beginning .NET developers.
Are you curious what’s inside your compiled .NET application? Do you want to see
the full range of power MSIL supports? Do you want to learn more about how the CLR
works? In this session, we’ll go “under the hood” to see how a compiled .NET assembly
is structured, how the CLR reads and processes your assembly, what you can do with
MSIL, and ways common .NET idioms are represented in MSIL.
Audience: Beginning to intermediate .NET developers.
Are you reluctant to move to .NET because you have too much legacy MFC code? Do
you want to make the switch now, instead of when circumstances force it upon you?
Then this tutorial session is for you. In this session, we’ll use refactoring and
automated tools to port an existing MFC DocView application to .NET, learning valuable
porting strategies in the process.
Audience: Beginning to intermediate C# developers.
Are you reluctant to move to .NET because you have too much legacy VB6 code? Do
you want to make the switch now, instead of when circumstances force it upon you?
Then this tutorial session is for you. In this session, we’ll use refactoring and
automated tools to port an existing VB6 forms and data application to .NET, learning
valuable porting strategies in the process.
Audience: Beginning to intermediate VB.NET
developers.
So you know your way around C# and VS.NET pretty well. You’re a wizard at the Wizards,
and you’re a coding fiend. You can crank out WinForms, WebForms, and even WebServices
at amazing speed. You’re getting more work done faster than you have ever done before.
But is that enough?
Not necessarily. Hand-rolled code that is easy to write isn’t always easy to maintain.
Wizard-generated code helps you to get the job done, but not always done efficiently
for long-term code maintenance, nor for short-term collaborative development. Other
programming aids are similarly double-edged swords. Yet VS.NET and C# actually support
powerful coding best practices that will encourage reuse and ease of maintenance
of your code. In this session, we will examine these best practices and related
coding standards that will make your C# code more polished and robust.
Audience: Beginning to intermediate C# developers.
Like many platforms, .NET supports application metadata, a mechanism for a module
to describe itself to external tools. But .NET goes farther: its metadata system
is fully extensible with .NET custom attributes, a way to define your own metadata.
What does that mean? Well, in this session, we’ll look at 10 fun tricks you can
do with custom attributes: 10 ways your assemblies can describe themselves for custom
tools that will help you to maintain and manage your code.
Audience: Beginning to intermediate .NET developers.
How to Stay Out of It, How
to Escape From It. Microsoft is singing a siren song. “Use .NET serialization,”
they say. “It’s easy!” And then they show some samples that show just how easy it
is; and you listen to the siren, and soon you’re trapped between Scylla and Charybdis,
facing unserializable data, exploding file sizes, and an inability to change your
class and module layouts. In the first half of this session, we’ll look at ways
to avoid the serialization trap by looking before you leap. In the second half,
we’ll look at ways to get out of the trap, for those who have already leaped.
Audience: Beginning to intermediate .NET developers.
Interactive demonstration of UML modeling for requirements
gathering, architecture, design, and coding. While the end product will be a
small amount of functioning .NET code, the lessons from this presentation apply
to non-.NET environments as well.
Audience: Beginning to intermediate developers.
analysts, designers, and managers.
Also Listed Under: Analysis and Design and UML.
VS.NET has a rich set of macro tools to allow you to automate common tasks in your
development processes; but sometimes, a simple macro is not enough. Sometimes you
need to add in new tools with full user interfaces, including tool windows and full
integration with VS.NET. In this session, we’ll examine the process of building
Add-Ins and Wizards for VS.NET.
Audience: Intermediate to advanced .NET developers.
Architecture and design patterns are well-studied common problems and standard starting
points for solutions. Using these starting points as a solid foundation, you can
focus your attention on the unique features of your code, trusting that the architecture
and major design decisions are covered. In this session, we’ll examine some common
architecture and design patterns, see how they translate into C# code, see how you
could modify and extend the pattern code, and see how you can use these patterns
to analyze, architect, and design a complex C# system.
Audience: Intermediate to advanced C# developers;
Intermediate to advanced analysts, designers, and managers.
Also Listed Under: Analysis and Design and UML.
Architecture and design patterns are well-studied common problems and standard starting
points for solutions. Using these starting points as a solid foundation, you can
focus your attention on the unique features of your code, trusting that the architecture
and major design decisions are covered. In this session, we’ll examine some common
architecture and design patterns, see how they translate into VB.NET code, see how
you could modify and extend the pattern code, and see how you can use these patterns
to analyze, architect, and design a complex VB.NET system.
Audience: Intermediate to advanced VB.NET
developers; Intermediate to advanced analysts, designers, and managers.
Also Listed Under: Analysis and Design and UML.
Investigate how particular design patterns are represented in
a mix of C# and VB.NET code.
Audience: Intermediate to advanced .NET developers;
Intermediate to advanced analysts, designers, and managers.
Also Listed Under: Analysis and Design and UML.
Learn how to extend the VSTS environment to support automated
project management.
Audience: All .NET developers, analysts, managers,
and testers.
Also Listed Under: Development Processes and
Practices.
Is your code full of ****? Let’s be honest: most code goes through periods of ****,
and a lot of code has areas that are full of ****. And of course, some code is nothing
but ****. **** happens, and you just have to clean up the mess. But if you don’t,
and you ship anyway, that’s when the **** hits the fan. If you don’t get your ****
together, your product can end up in the toilet. VSTS has a lot of tools to help
you flush the ****, but your team may need to be trained to learn to use them. This
session will help you learn to housebreak them. We’ll cover the most talked-about
new features, unit testing and test-driven development; but we’ll also look at other
support for testing and metering and assessing. We’ll also go through some simple
checklists your team can use to create better tests, and then we’ll see how code
snippets and automation can help to implement those tests. And we’ll look at how
testers can use VSTS to take a larger, earlier role in system development.
Audience: Beginning to intermediate .NET developers, analysts, managers, and testers.
Some projects use VB.NET, while others use C#, Managed C++, or may be a mix. Some
projects are Web-based, while others ran on a desktop or in a console. But no matter
how they may differ, all projects are the same in one regard: they all have requirements.
And so requirements definition and management should be at the core of any good
process. In this session. We’ll learn how VSTS helps you to define, store, track,
and report requirements. And we’ll also learn some simple yet powerful requirements
patterns that you can apply to most projects and processes.
Audience: Beginning to intermediate .NET developers, analysts, managers, and testers.
Does your project use VB.NET or C#? Chances are, your customers don’t know and don’t
care. Will your project be on time or late? Now that they care about! How much will
it cost? When will it be done? These questions can be more trouble than the technology
or languages you use; and they can also be the most important questions for your
executives and your customers. This session will show team leads and team members
how VSTS helps them in the three key resource management activities: estimating
time and costs; planning and scheduling the effort; and tracking, reporting, and
correcting as the project runs. Along the way, we’ll discuss some basic estimating,
scheduling, and planning techniques.
Audience: Beginning to intermediate .NET developers, analysts, managers, and testers.
VSTS ships with the Microsoft Solutions Framework (MSF), a standard process for
software development. This is a process that Microsoft recommends; but for many
teams, this “One Microsoft Way” won’t be the right way. But fear not! VSTS is customizable,
in ways both large and small. In this session, we’ll look at ways to adapt the MSF
to your team and your project. Then we’ll go beyond that, and see how VSTS allows
you to build your own process templates. With these, you can incorporate any of
the popular development processes into VSTS, or even
create your own.
Audience: Beginning to intermediate .NET developers, analysts, managers, and testers.
For details, slides, and code samples, click here.
Audience: Beginning to intermediate C# and VB.NET developers.
For details, slides, and code samples, click here
.
Audience: Intermediate to advanced C# and VB.NET developers.
So why aren't you writing Tablet PC applications with .NET yet?
Do you think it's too difficult? Do you think you're too busy to learn the Tablet
PC API? Well, Martin L. Shoemaker (of The Tablet UML Company) says you're wrong.
Or do you just not see what sort of Tablet PC app you might build? Do you think
that there's no great Tablet PC applications out there for you? Well, Martin says
you're wrong again.
And Martin's so sure you're wrong, he's going to prove it to you by building some
simple little Tablet PC samples -- samples you can easily adapt into your own applications
-- each written in under 60 seconds.
Then after each sample is running, he'll explain to you what he did, how he did
it, and how you might expand on it. Some of the samples he'll build include:
- 60 Seconds to Ink: Capturing Ink in a window in your application.
- 60 Seconds to Ink Anywhere: Capturing Ink in any window in your application.
- 60 Seconds to Programmatic Ink: Adding Strokes programmatically to an Ink surface.
- 60 Seconds to Selecting and Resizing: Manipulating the Ink that you draw.
- 60 Seconds to Erasing: Erasing the Ink that you draw.
- 60 Seconds to Color: Drawing Ink in multiple colors.
- 60 Seconds to Transparency: Drawing with transparent Ink.
- 60 Seconds to Pen Shapes: Drawing with different shapes and sizes of pens.
- 60 Seconds to Inkons: Representing data as objects within an Ink drawing.
- 60 Seconds to Simple Handwriting Recognition: Simple handwriting in a form.
- 60 Seconds to Handwriting Recognition On Demand: Handwriting recognition mixed with
typing.
- 60 Seconds to Handwriting Recognition Anywhere: Handwriting recognition from any
Ink surface.
- 60 Seconds to Speaking: A simple talking application.
And just in case those samples don't inspire you to devise a great new Tablet PC
application, Martin will finish the presentation by spending 60 seconds (probably
more) describing each of ten different killer Tablet PC applications that he's just
too busy to write himself, but which he thinks somebody should
be writing.
Audience: Beginning Tablet PC developers with some .NET experience.
A lot of discussions about the Tablet PC focus on text recognition. While the text
recognition performance is pretty impressive, there’s another recognition mode that
may be more useful for your apps: gestures. The gesture recognizer will recognize
over 40 different shapes, and tell you when the user draws them. This allows you
to build “Smart Cocktail Napkin” applications, where the user draws a picture that
has meaning to other users; and the software uses the simple shapes in the picture
to recognize what the user drew. But for you to succeed with this technique, you’ll
need to define a shape grammar: a set of drawing contexts, the set of shapes that
have meaning in a given context, and the set of .NET code types that will correspond
to those shapes.
But gesture recognition is only part of the power of the 21st Century Cocktail Napkin.
In articles and books on Tablet PC development, there’s talk about Big Ink (an entire
Ink image is one set of strokes and content) and Little Ink (an image made up of
small sets of strokes within an image that represent objects within the code); but
most programming samples only demonstrate Big Ink, which is the default mode for
the Tablet PC API. We’ll explore the difference between Big Ink and Little Ink and
why you might prefer Little Ink for your “Smart Cocktail Napkin” applications.
In this session, we’ll describe the gesture recognizer, review the set of recognized
gestures, examine what goes into a shape grammar, and look at a generic shape grammar
engine written for .NET. We’ll also look at a sample .NET application built on top
of the shape grammar engine. Then we’ll discuss a wide range of implementation issues
in building your own Little Ink implementation, and then look at a generic Little
Ink engine for .NET. We’ll then integrate the Little Ink engine into our shape grammar
engine, ending with a complete 21st Century Cocktail Napkin.
Audience: Intermediate Tablet PC developers with some .NET experience.
An Introduction to Tablet
PCs. The Tablet PC is here, and it'll change the way you work... and
the way you program. Combining pen input, speech input, light-weight devices, WiFi,
and a powerful superset of Windows XP Professional, the Tablet PC fills an important
niche in mobile computing. You can control a Tablet PC by drawing and writing and
filling in forms, by standard and custom gestures, and simply by speaking to it.
For mobile workers who need the power of a laptop with the ease-of-use a Pocket
PC, the Tablet PC allows them to work in a way that's natural to them, rather than
being constrained by the keyboard and the mouse. This makes them popular in fields
as diverse as insurance, medicine, animation, and yes, software design.
In this session, we'll examine the Tablet PC:
- What it is. The nature of the platform. Different configurations. Input with Ink
and Gestures. Input with Speech.
- What it isn't. How the Tablet PC differs from prior pen-based efforts and from other
mobile devices.
- What it does. Usage scenarios. How to recognize a good Tablet PC need. Tablet PC
application design considerations.
- How it does it. Programming the Tablet PC under .NET, live on stage! Capturing Ink.
Serialization. Text recognition. Recognizing gestures. Working with images.
We'll finish by looking at Tablet UML, an example of a full-fledged Tablet PC application.
Investigates Tablet PC capabilities, including sample
applications.
Audience: All .NET developers; Intermediate analysts
and managers.
Tablet PC Programming.
A more code-centered view of the Tablet PC, examining an app driven by pen and
voice, without keys.
Audience: All .NET developers.
Investigates what makes a good Tablet PC application, along
with how to identify good Tablet PC functionality from a user's perspective.
Audience: Intermediate developers, designers,
analysts, and managers.
Tablet PCs: A User's Perspective
Explores many powerful ways that the Tablet PC can make users
more productive.
Audience: General users.
.NET now supports the latest powerful speech APIs from Microsoft and other vendors,
allowing new ways for users to interact with your applications. In this session,
we’ll look at code samples for speech input and output in WinForms, WebForms, and
telephony applications.
Audience: Intermediate to advanced .NET developers.
Explains and demonstrates using UML state diagrams and state
modeling to define a speech grammar for controlling .NET applications.
Audience: Intermediate to advanced .NET developers;
Intermediate to advanced analysts, designers, and managers.
Also Listed Under: Analysis and Design and UML.
An introduction to UML and the role it can play in all aspects
of software development.
Audience: Beginning to intermediate developers.
analysts, designers, and managers.
Interactive demonstration of UML modeling for requirements
gathering, architecture, design, and coding. While the end product will be a
small amount of functioning .NET code, the lessons from this presentation apply
to non-.NET environments as well.
Audience: Beginning to intermediate developers.
analysts, designers, and managers.
Also Listed Under: General .NET Programming.
Analysis with an End User
Focus. In this session, we shall demonstrate and practice requirements modeling
and business modeling centered on Actors. We shall see how the focus on Actors allows
a very rapid development of a picture of a business or a system; and we will examine
useful ways to organize a UML model to reflect an Actor-driven model. Attendees
should already understand the basics of Use Case Diagrams.
Audience: Beginning to intermediate developers.
analysts, designers, and managers.
This session will introduce you to the world of Patterns in software development,
from process patterns all the way to design patterns. We'll cover the concept of
patterns: what they are and how they form an engineering framework for software
best practices. We'll also discuss a number of classic patterns, as well as the
concrete problems these patterns solve, their intent, the motivation for using them,
the consequences of choosing a pattern, their applicability, and implementation
issues. Each pattern will be presented first from the traditional object-oriented
perspective, then as a live, interactive demo. (Be prepared for audience participation!)
Audience: Beginning to intermediate developers.
analysts, designers, and managers.
Style Guidelines for UML
Modeling. UML is a language, a tool for communication. And like any language,
it has both syntax and style. In this session, we shall focus on some style guidelines
which will make your diagrams more useful as communications tools. We will compare
diagrams that break the rules with diagrams that follow them, and see how the rules
help communicate the point of each diagram.
Audience: Intermediate developers, analysts,
designers, and managers.
Function points are an industry standard software size estimation tool. Though they
are in wide use, function points were developed for use in data-driven systems,
not object and component systems. In this session, we will study how UML models
can feed into a function point analysis to generate an estimate. We will also discuss
some extensions to traditional function point methods to reflect two features common
to UML design processes: component design and continuous requirements discovery.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
Architecture and design patterns are well-studied common problems and standard starting
points for solutions. Using these starting points as a solid foundation, you can
focus your attention on the unique features of your code, trusting that the architecture
and major design decisions are covered. In this session, we’ll examine some common
architecture and design patterns, see how they translate into C# code, see how you
could modify and extend the pattern code, and see how you can use these patterns
to analyze, architect, and design a complex C# system.
Audience: Intermediate to advanced C# developers;
Intermediate to advanced analysts, designers, and managers.
Also Listed Under: General .NET Programming.
Architecture and design patterns are well-studied common problems and standard starting
points for solutions. Using these starting points as a solid foundation, you can
focus your attention on the unique features of your code, trusting that the architecture
and major design decisions are covered. In this session, we’ll examine some common
architecture and design patterns, see how they translate into VB.NET code, see how
you could modify and extend the pattern code, and see how you can use these patterns
to analyze, architect, and design a complex VB.NET system.
Audience: Intermediate to Advanced VB.NET
developers; Intermediate to advanced analysts, designers, and managers.
Also Listed Under: General.NET Programming.
Investigate how particular design patterns are represented in
a mix of C# and VB.NET code.
Audience: Intermediate to Advanced .NET developers;
Intermediate to advanced analysts, designers, and managers.
Also Listed Under: General.NET Programming.
Explains and demonstrates using UML state diagrams and state
modeling to define a speech grammar for controlling .NET applications.
Audience: Intermediate to Advanced .NET developers;
Intermediate to advanced designers, analysts, and managers.
Also Listed Under: Speech Programming in .NET.
Learn how to extend the VSTS environment to support automated
project management.
Audience: All .NET developers, analysts, designers,
managers, and testers.
Also Listed Under: General.NET Programming.
Looks at strategies and techniques for refactoring as a
development subprocess.
Audience: Intermediate to advanced developers,
designers, and managers.
Based on an upcoming book: techniques customers can use to
help developers to do their jobs better, so that they can help you do your job
better.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
Explores common techniques for requirements gathering,
management, and modeling.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
Explores the basic practices and rationale for project
estimation.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
This session provides a comparison of many different popular development processes,
with a focus on the strengths and weaknesses of each. The main lesson you should
learn from this session is simple: no process is automatically good or automatically
bad; but choosing a practice that doesn’t fit your environment or customer or team
or organization is always a bad practice. So we’ll look at Waterfall, Spiral, Staged
Delivery, Evolutionary Delivery, the Unified Process, and eXtreme Programming; and
we won’t pass a judgment on any process (not even Waterfall), but we’ll try to present
them on an even footing so that you can better understand what might be a better
process for your project.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
An examination of the Unified Process, concentrating on the
roles people play and the work products that result.
Audience: Intermediate to advanced developers,
analysts, designers, managers, and testers.
An introduction to the values and principles of Agile
Development, along with an investigation of some AD processes.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
An examination of eXtreme Programming, concentrating on the
roles people play, the XP practices, and the work products that result.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
AntiPatterns for Agile
Development. Agile development processes like Scrum, XP, and Agile Modeling
have some proven successes and a lot to offer. Misapplied, however, they can be
every bit as destructive as the indiscriminate use of GOTOs; only instead of spaghetti
code, you end up with spaghetti processes. In this session, we will examine many
ways in which agile processes can be misapplied, as well as how to determine if
agile development is even right for your situation. We will also discuss how to
recognize and respond to the signs of spaghetti.
Audience: Intermediate to advanced developers,
analysts, designers, and managers.
Recovery Plans for a
Project in Crisis. So you’ve studied, and you’ve decided you need to upgrade
your software development processes. Maybe you want to try the Unified Process,
or maybe you’re leaning toward an Agile Development approach. But in either case,
you may fall prey to a common worry: “Wow! This looks really powerful! But how will
we ever have time for it when we’re in the middle of a crisis right now?” (Some
people add, “Maybe next project.” Then others just laugh cynically…) In this session,
we will discuss Recovery Plans: approaches to implementing process improvement during
the middle of a software
crisis.
Audience: All developers, analysts, designers, and
managers.
2300 years ago, a man named Aesop gathered the accumulated software development
knowledge of the ancient Greeks, and presented the knowledge to history. However,
since so few people in the intervening millennia knew anything about software, they
misinterpreted Aesop’s lessons as simple morality fables, rather than as hard advice
for software managers. Now you can learn what Aesop had to teach us about software
development processes and management.
Audience: All developers, analysts, designers, and
managers.
About Martin L. Shoemaker
Martin is a software developer with 21 years experience in the industry. He has
worked in the fields of color science, on-line shopping, databases, material
handling, medical imaging, and customer relations management. He has twice been
recognized by Microsoft Corporation as an MVP for Visual Development with C#.[1]
Martin is also a frequent speaker, having presented to the Grand Rapids chapter
of the Information Technology Managers Association, the Detroit Colour Council,
the Ann Arbor IT Zone, the Ann Arbor Computer Society, the Great Lakes Area
.NET User Group, the West Michigan .NET User Group, Software Development West,
Software Development East, Software Development Best Practices, Visual Studio
Live, Visual C++ Developers Conference, UML World, Rational Users Conference,
Web Services Edge, Rubi-Con, and the Chattanooga .NET User Group. As a speaker
for the International .NET Association (INETA), he has presented to the Omaha
.NET User Group, the Oklahoma .NET Users Group, the Tulsa .NET User Group, the
Greater Lansing .NET User Group, the Chicago .NET Users Group, the Little Rock .NET Users Group, BeanTown .NET, the
Huntsville .NET Users Group, the Findlay Ohio Area .NET User Group, the Central
Maryland ASP Professionals, the Cincinnati .NET User Group, the Dayton .NET Developers
Group, the Michiana Area .NET Users Group, the Huntsville VS.NET Users Group, Wichita
Developers .NET, the Chippewa Valley .NET User Group, the Falcon.NET Association,
the Cleveland .NET Special Interest Group, .NET Users of Fort Wayne, and the Lubbock
.NET Users Group. His most popular presentations are Richard Hale Shaw's UML
BootCamp, which he wrote and presents. He has presented this course both in
public settings and for individual clients including:
-
Microsoft
-
Intermec
-
Siemens Dematic (Rapistan Division)
-
University of Michigan
-
Target
-
EPOS Corp
-
Syngenta
-
LaBatts
-
NISC
-
SER Solutions
-
Silicon Energy
-
Sports Media
-
Tyco International
-
Hewlett-Packard
-
Best Software
-
CCH
-
Intuit
-
Shaw Industries, Inc.
-
Lanac
-
Afni
-
Fleet Lease Disposal, Inc.
Martin is the founder of the Tablet UML Company (http://www.TabletUML.com),
a Hopkins MI company that makes software tools for the Tablet PC. He is also
available as an instructor and as a consultant and mentor, offering his
expertise to clients who need requirements analysis and software design
services, as well as custom software in the Windows and .NET environments.
Martin has one primary philosophy when it comes to software: There is a better
way to design software and systems, and we want to bring it to you.
“The Microsoft MVP Program is a worldwide award and recognition program that
strives to identify amazing individuals in technical communities around the
world. Microsoft MVPs are recognized for both their demonstrated practical
expertise and willingness to share their experience with peers in Microsoft
technical communities.” From
http://mvp.support.microsoft.com/communities/mvp.
|
|
