|
|
|
<<< Previous speaker
|
next speaker >>>
|
Joseph Yoder, Software Patterns writer
Joseph Yoder is a founder and principle of The Refactory, Inc., a company focused on software architecture, design, implementation, consulting and mentoring on all facets of software development. Joseph is an international speaker and pattern author and long standing member of The Hillside Group, a group dedicated to improving the quality of software development. He is co-author of the Big Ball of Mud pattern, which illuminates many fallacies in the approach to software architecture. Joseph has chaired the Pattern Languages of Programming Conference (PLoP), as well as presented tutorials and talks at conferences such as JAOO, OOPSLA and ECOOP.
Joe currently resides in Urbana, Illinois where he oversees a team of developers who have constructed many systems based on enterprise architecture using the .NET environment. Other projects involve working in both the Java and .NET environments deploying Domain-Specific Languages for clients. Joe thinks software is still too hard to change. He wants do something about this and believes that with good patterns and by putting the ability to change software into the hands of the people with the domain knowledge seems to be some promising avenues to solve this problem.
|
Presentation: "Introduction: Architecture for the Architect"
Time:
Wednesday 10:20 - 10:30
Location:
Stanford
Abstract: If on the other hand you think Architecture is about nurturing and communicating a technology vision, and that Enterprise Architecture is about finding the simplicity amongst all that complexity - and if you've been wondering whether you are the only person who thinks like that - then come and listen to some like-minded industry leaders share their thoughts and experiences.
Presentation: "Patterns in Architecture"
Time:
Wednesday 10:30 - 11:30
Location:
Stanford
Abstract: As stated in the Patterns of Software Architecture Book, “An
architectural pattern expresses a fundamental structural organization
schema for software systems. It provides a set of predefined subsystems,
specifies their responsibilities, and includes rules and guidelines for
organizing the relationships between them.” From this we can see that in
comparison to Design Patterns, Architectural Patterns are considered
larger in scale. From a software engineering perspective, they are the
idea of describing architectural design ideas as prototypical examples
and reusable pieces. Many different types of common architectural
patterns arise from different types of systems (i.e. Pipes, Filters,
Model-View-Controller, Layers, Blackboard, etc). Quite often, you will
see a common grouping of common design and architectural patterns
implemented in frameworks which can be used to more quickly specify and
develop software programs.
It could be said that all software systems have some form of
architecture, even if it is not explicitly described. This makes sense
if you regard the architecture as existing in the system itself. This
could of course be the architecture of a Big Ball of Mud, however some
form of architecture exists in any program or software system. Thus,
common Patterns of Architecture arise from different architectural
styles. This talk will give an overview of some core Architectural
Patterns. Additionally some common Patterns that arise from different
Architectural Styles will be examined and described such as those seen
in building Adaptive Systems, Service Oriented Architecture, and the like.
|
 |
| |
