TriJUG Presentation Topic Survey

 
http://www.surveymonkey.com/s.asp?u=684501745352
 
Please follow the above link to provide your input regarding topics for
future TriJUG meetings.

Thank you,
   Harold Meder.
 
------------------ 
 
See the following link for more information regarding the presentations SUN
has to offer.

http://developers.sun.com/events/techdays/agendas/FY06abstracts.html 
You'll probably need to sign up for a Sun Developers' Network id to navigate
to that page, if you haven't already done so (the SDN is pretty innocuous in
terms of spam and the like.

------------------ 

See appended information regarding presentations offered by Brian Sletten
and Stuart Halloway.


------------------------------------ 
March 20th with Brian Sletten
------------------------------------ 

Brian Sletten has a background as a system architect, a developer, a mentor
and a trainer. His experience has spanned defense, finance and commercial
domains with communication software, 3D simulation/visualization systems,
Grid Computing and a Semantic Web-based document processing pipeline. He
lives in Fairfax, VA where he runs his software consulting business, Bosatsu
Consulting, Inc.

Session listing:

1). Applied Object-Oriented Metrics
Object-oriented code metrics are a little like Artificial Intelligence: 
those who did it twenty years ago roll their eyes at the thought and
prophesy the same ultimate failure as applicability now. Those who grew up
with Java are approaching the topic with new eyes and are finding useful
ways of incorporating metrics into their projects. Come hear about tools and
ways to measure properties of software, how they might be beneficial and
where you are likely to go astray with this approach.

2). Applied AOP
Most people new to Aspect-Oriented Programming (AOP) are fed up with
separation of concerns zealots explaining how great their techniques are at
dealing with... logging. Ok, you get it. Logging is a cross-cutting concern
that can be appropriately modularized. What else does AOP have to offer? A
lot, it turns out. This talk will give an introduction to the motivations of
AOP as well as a series of concrete examples drawn from enterprise and
client side Java. Come learn how AspectJ-flavored AOP can begin to benefit
you immediately either in development or production environments. Learn how
to enforce architectural policies, find Swing threading issues, reduce the
invasiveness of the Observer design pattern or even improve the reusability
of your domain models.

3). Applied Design Patterns
Just about every modern software developer has a copy of the Gang of Four
"Design Patterns" book sitting on a shelf; many of them have actually read
it. The dark secret of the patterns community is that there is often a large
gulf between whiteboard simplicity and real-world complexity. Language
choice plays a part in the design (and even importance) of patterns. The
situation is made even more confusing by the fact that many of the core
patterns have now been "voted off the island" for one reason or another.
This talk will give a pragmatic overview of the motivations behind design
patterns and will focus on applying a handful of the GOF patterns to example
scenarios in Java, Ruby and C#. A quick introduction to the role AOP plays
in changing the patterns landscape will also be covered.

4). Introducing the Semantic Web
Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al
inform us that what we have seen so far is just the beginning. His original
plans at CERN were larger and grander. The Semantic Web is the new vision of
machine-processable documents and metadata to improve search, knowledge
discovery and data integration and management. While there are many
naysayers chiding such grand visions, there are also pragmatic and useful
technologies emerging that can be applied today.

5). JmDNS : Easy Service Discovery for the 21st Century Service-oriented
architectures (SOAs) are all the rage. But how do you find all of these
services once they are deployed? Configuration files are so 90's. Software
of the 21st Century should be able to find related services and components
without users having to specify particular configurations at start up. The
IETF's ZeroConf multicast DNS protocol was designed to solve exactly this
problem. JmDNS is Java-based open source implementation of this capability
that allows local-link applications to find and use automagically discovered
capabilities. 
Apple's Rendezvous technology is another open-source ZeroConf implementation
behind many of the exciting applications it is building for OS X these days.
Come learn how you can interact with these or your own service
discovery-savvy applications without even having to learn how to spell UDDI.
Bring your wireless notebooks to participate in a service-oriented
environment (please have a working Java environment as we won't have time to
debug installation issues).

6). NetKernel : XML Processing for the 21st Century A wise man once said,
"XML is like lye. It is very useful, but humans shouldn't touch it." If
you've had to incorporate XML into your project by hand, you have probably
been burned by getting too close. NetKernel turns this wisdom on its head
and encourages you to use XML like the liquid data stream you want it to be.
Imagine the simplicity of REST married to the power of Unix pipes. Come see
how this open source / commercial product built on a compelling modern
architecture can be used to create, manipulate and transform XML.


------------------------------------
April 17th with Stuart Halloway
------------------------------------ 

Stuart Dabbs Halloway is a co-founder and partner at Relevance, LLC. 
Prior to founding Relevance, Stuart was the Chief Technical Officer at
DevelopMentor, the industry's leading training company focusing exlusively
on software developers. Stuart is the author of Component Development for
the Java Platform, part of the DevelopMentor book series and available for
free online. Stuart serves on the board of TechEngage. 
Stuart writes regularly, including a long-running column for the Java
Developer Connection and articles for JavaPro magazine and InformIT. 
Stuart regularly speaks at industry events including the No Fluff, Just
Stuff Java Symposiums and JavaOne. Prior to DevelopMentor, Stuart worked as
a lead engineer and project manager, shipping successful projects for
Prentice Hall, National Geographic, and Duke University's Humanities
Computing Facility. He received his B.S. and M.P.P. from Duke University in
1990 and 1994, respectively.

Session listing:

1). Spring Dependency Injection
Dependency Injection (DI) is the cornerstone of Spring. The core concept is
quite simple, but (surprise!) actual practice can become complex. To take
full advantage of Spring DI, you need to understand not only the basics on
configuration, but also the container lifecycle model and the various hooks
provided by the framework.

2). Programming Java Concurrency
Java has always provided a model for concurrency and threads. With Java 1.5,
this model received a major facelift. Learn how to use the new concurrency
utilities to build responsive, scalable, and correct concurrent
applications.

3). Spring Fundamentals
The Spring framework is one of the fastest growing open source frameworks.
New job postings are gaining rapidly, and many customers are adopting Spring
instead of heavier alternatives. In this session, we'll introduce Spring.
You'll see how Spring can give you much of the power of EJB, without the
complexity or pain.

4). Java Platform Security and JAAS
The Java platform is built from the ground up with security in mind. 
This talk will introduce the security features of the J2SE, building quickly
from the basic classes to realistic examples.

5). Ajax Architecture
Ajax applications have unique architectural challenges and opportunities.
This presentation will show you how to take advantage of the Ajax's
strengths, and work around its quirks.

6). Introduction to Java Reflection
Reflection is writing code that manipulates itself. Well-written reflective
code automates a broad class of repetitive, error-prone programming tasks.
Poorly-written reflective code obfuscates programs and destroys the benefits
of the type system. We'll focus on the former.

7). Cryptography for Programmers
For centuries people have used crypto to build (and break) secure systems.
Computers have only raised the pitch of conflict, providing enormous
cryptographic power at commodity prices. Most programmers do not write their
own crypto libraries, instead relying on the services of an operating system
or virtual machine. But even with all this support, building secure systems
is a daunting task.

8). Spring AOP
Learn to use Spring AOP, aspect injection. and AspectJ integration