O IME/USP apresentou, com apoio da Objective Solutions, uma excelente oportunidade de aperfeiçoamento e reciclagem para profissionais na área de desenvolvimento de software: um curso avançado de projeto e desenvolvimento de software orientado a objetos apresentado por um grande especialista internacional da área.
O curso foi ministrado por Joe Yoder, especialista que conta com quase duas décadas de experiência em desenvolvimento de software, é o autor de vários padrões e artigos apresentados em conferências internacionais e trabalha como consultor em desenvolvimento de software orientado a objetos na empresa norte-americana Refactory, Inc. (http://www.refactory.com).
Os principais tópicos abordados no curso foram:
- Padrões de Projeto Orientados a Objetos
- Testes Automatizados
- Architecture and Design of Adaptive Object-Models
- Design Patterns - Java/C# Edition
- slides [pdf]
151 MiB (158423040 bytes), 156980 quadros, 29.97 fps, 1h27min14s.
113 MiB (118138880 bytes), 165358 quadros, 29.97 fps, 1h31min54s.
131 MiB (137261056 bytes), 165422 quadros, 29.97 fps, 1h31min56s.
103 MiB (107421696 bytes), 122482 quadros, 29.97 fps, 1h08min04s.
- exemplos (da edição do curso ministrada em 2004)
- Refactoring Principles
- Escape from the spaghetti code jungle - Big ball of mud
- slides [pdf]
- Architectural Patterns for Enabling Application Security (2004)
- slides [pdf]
- Patterns for Making Business Objects Persistent in a Relational Database (2004)
- slides [pdf]
- A Framework for Financial Modelling (2004)
- slides [pdf]
- Vídeo: XviD, 352x240.
- Áudio: MP3, 64 Kibit/s, 32000 Hz, mono.
- Programas compatíveis para Linux: xine, MPlayer.
- Codec para Windows: Nimo's Codec Pack (instale o codec XviD).
- Programas compatíveis para Mac OS X: MPlayer OS X, VLC, ffmpegX.
Architectures that can dynamically adapt to changing requirement are sometimes called "reflective" or "meta" architectures. We call a particular kind of reflective architecture an "Adaptive Object-Model (AOM)" architecture. An Adaptive Object-Model is a system that represents classes, attributes, relationships, and behavior as metadata. It is a model based on instances rather than classes. Users change the metadata (object model) to reflect changes to the domain model. These changes modify the system's behavior. In other word, it stores its Object-Model in XML files or in a database and interprets it. Consequently, the object model is adaptive; when the descriptive information for the object model is changed, the system immediately reflects those changes.
We have noticed that the architects of a system with Adaptive Object-Models often claim this is the best system they have ever created, and they brag about its flexibility, power, and eloquence. At the same time, many developers find them confusing and hard to work with. This is due in part because the developers do not understand the architecture.
This tutorial will give a description of the Adaptive Object-Model architectural style and will make it easier for developers to understand and build systems that need to adapt to changing requirements.
The ongoing surge in interest in software patterns has placed a long overdue spotlight on how good programs are put together. Design patterns are distillations of design insight drawn from practice. They capture recurring solutions to software design problems. Once a designer is familiar with these patterns, he or she can use them in his or her own designs without having to reinvent them from first principles. Using patterns allows developers to make their systems more flexible, reusable, adaptable, and readable. Patterns also provide a common vocabulary for concisely communicating these architectural insights. This course examines all twenty-three patterns in Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1994). The course begins with a detailed review of what patterns are and how they can be used to help design object oriented software. We examine the most important patterns in depth, while ensuring that attendees have seen all the patterns at least once. In addition, the Type Object and Properties patterns will be reviewed, and their roles in building highly configurable dynamic systems will be examined. The course will be taught using examples from Java, and all exercises will be conducted in Java and UML. Once the class is over, students should understand design patterns, know where they fit in the software development process, and be able to leverage them to solve design problems efficiently.
Refactoring code to make it more maintainable and extendable has become a more mainstream practice. Refactoring is the process of changing software without altering its external behavior. It is done in such as way to improve the structure of the code to allow for later extensions or to make maintenance of the code easier. It is important to refactor your code in a disciplined way to minimize disruptions and to allow the system to safely evolve. Improving a system's structure and readability through refactoring enhances its comprehensibility, readability, and maintainability.
This tutorial will teach attendees how to recognize "code smells", or signs that code needs to be refactored. It takes you through some of the common refactorings as provided by tools such as the Refactoring Browser and Eclipse and those outlined in Martin Fowler's Refactoring book, teaching you the correct discipline for refactoring your code. Various code examples will be used to illustrate how and when to refactor. Tools and Testing techniques to support refactoring will also be examined. The class will examine how to apply object-oriented design patterns to guide your refactoring decisions.
Joseph W. Yoder has worked on the architecture, design, and implementation of various software projects dating back to 1985. These projects have incorporated many technologies and range from stand-alone to client-server applications, multi-tiered, databases, object-oriented, frameworks, human-computer interaction, collaborative environments, and domain-specific visual-languages. In addition these projects have spanned many domains, including Medical Information Systems, Manufacturing Systems, Medical Examination Systems, Statistical Analysis, Scenario Planning, Client-Server Relational Database System for keeping track of shared specifications in a multi-user environment, Telecommunications Billing System, and Business & Medical Decision Making.
Joseph has assisted many companies with the development of software applications, specifically object-oriented frameworks, enterprise components, and web-based systems. Recently he has been teaching Java, Smalltalk, Patterns, Frameworks, Object-Oriented Analysis and Design and has mentored analysts and developers on many of their applications. He has also worked with the management and development of a reusable Enterprise Class Libraries.
Joe is the author of over two-dozen published patterns and has been working with patterns for a long time, writing his first pattern paper in 1995, and was the conference chair for the PLoP'97, conference on software patterns and was the programming chair of The Second Latin American Conference on Pattern Languages of Programming.
Local: Auditório do Instituto Oceanográfico
Cidade Universitária - USP
São Paulo - SP
Data: sábado 23/8, 9:00 às 17:00
domingo 24/8, 9:30 às 12:30
Pré-requisitos: Conhecimentos básicos de programação orientada a objetos. Os exemplos dados durante o curso utilizarão a linguagem Java.
Os inscritos no curso puderam ainda assisitir gratuitamente à palestra avançada "Adaptive Object-Model Architectures" descrevendo pesquisas avançadas na área de sistemas dinâmicos orientados a objetos ministrada por Joe Yoder, sexta-feira, 22/8 às 14:00 na sala B-5 do IME/USP.