Your SlideShare is downloading. ×
×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

OOPSLA 05 - AOP – Aspect Oriented Programming

690
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
690
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. OOPSLA 05OOPSLA 05 Amiram Yehudai A subjective reportA subjective report
  • 2. 2 ProgramProgram  Invited speakersInvited speakers  Technical papersTechnical papers  Practitioner reportsPractitioner reports  Expert panelsExpert panels  DemonstrationsDemonstrations  Educational symposiaEducational symposia  WorkshopsWorkshops  TutorialsTutorials  The Onward! trackThe Onward! track  PostersPosters  ……
  • 3. 3 Educators' SymposiumEducators' Symposium  Agile TeachingAgile Teaching Monday, 8:30, 1 hour 30 minutes, San Diego RoomMonday, 8:30, 1 hour 30 minutes, San Diego Room  Teaching TechniquesTeaching Techniques Monday, 10:30, 1 hour 30 minutes, San Diego RoomMonday, 10:30, 1 hour 30 minutes, San Diego Room  Keynote AddressKeynote Address Monday, 13:30, 1 hour 30 minutes, San Diego RoomMonday, 13:30, 1 hour 30 minutes, San Diego Room  Teaching ToolsTeaching Tools Monday, 15:30, 45 minutes, San Diego RoomMonday, 15:30, 45 minutes, San Diego Room  Looking to the FutureLooking to the Future Monday, 16:15, 1 hour 15 minutes, San Diego RoomMonday, 16:15, 1 hour 15 minutes, San Diego Room  Demos and PostersDemos and Posters Monday, 8:30, 9 hours, San Diego RoomMonday, 8:30, 9 hours, San Diego Room
  • 4. 4 Educators' SymposiumEducators' Symposium Agile TeachingAgile Teaching  The symposium begins with an interactiveThe symposium begins with an interactive presentation that illustrates agility in thepresentation that illustrates agility in the classroom via a Scrum sprint with studentclassroom via a Scrum sprint with student apprentices.apprentices.  Opening RemarksOpening Remarks Eugene WallingfordEugene Wallingford  Apprenticeship Agility in AcademiaApprenticeship Agility in Academia David West, Pam RostalDavid West, Pam Rostal
  • 5. 5 Apprenticeship Agility inApprenticeship Agility in AcademiaAcademia  David West, Pam Rostal, New Mexico Highlands UniversityDavid West, Pam Rostal, New Mexico Highlands University  This presentation will use multimedia and scripted theater toThis presentation will use multimedia and scripted theater to illustrate a typical development iteration as practiced by theillustrate a typical development iteration as practiced by the apprentices of the NMHU Software Developmentapprentices of the NMHU Software Development Apprenticeship Program. Seven students and one facultyApprenticeship Program. Seven students and one faculty member will conduct a thirty-minute Scrum sprint usingmember will conduct a thirty-minute Scrum sprint using minutes instead of days or hours as our unit of measure. Byminutes instead of days or hours as our unit of measure. By sharing our insights into overcoming the disruptions,sharing our insights into overcoming the disruptions, distractions, and impediments of the academic environment,distractions, and impediments of the academic environment, we hope to convey ideas that will be useful to all professionalwe hope to convey ideas that will be useful to all professional software developers and educators who must respond to thesoftware developers and educators who must respond to the challenge of teaching and experiencing agile softwarechallenge of teaching and experiencing agile software development techniques in an "inhospitable" environment.development techniques in an "inhospitable" environment.
  • 6. 6 Educators' SymposiumEducators' Symposium Teaching TechniquesTeaching Techniques  A Laboratory for Teaching Object-OrientedA Laboratory for Teaching Object-Oriented Language and Design Concepts with TeachletsLanguage and Design Concepts with Teachlets Axel SchmolitzkyAxel Schmolitzky  Teaching OO Methodology in a Project-Driven CS2Teaching OO Methodology in a Project-Driven CS2 CourseCourse Barry Kurtz, Frank Barry, James WilkesBarry Kurtz, Frank Barry, James Wilkes  Modeling OO DesignModeling OO Design Robert RistRobert Rist  Roles of Variables in Object-Oriented ProgrammingRoles of Variables in Object-Oriented Programming Petri Gerdt, Pauli Byckling, Jorma SajaniemiPetri Gerdt, Pauli Byckling, Jorma Sajaniemi
  • 7. 7 A Lab for Teaching OOA Lab for Teaching OO Concepts with TeachletsConcepts with Teachlets  A Laboratory for Teaching Object-Oriented Language andA Laboratory for Teaching Object-Oriented Language and Design Concepts with TeachletsDesign Concepts with Teachlets  Axel Schmolitzky, HamburgAxel Schmolitzky, Hamburg  Teachlets are a new method originally developed to teachTeachlets are a new method originally developed to teach design patternsdesign patterns.. Based on executable code, a problem is setBased on executable code, a problem is set that is to be solved collaboratively and interactively by all thethat is to be solved collaboratively and interactively by all the participants of a teaching unitparticipants of a teaching unit.. A moderator is on hand toA moderator is on hand to operate the computer, the development environment andoperate the computer, the development environment and video projector when called upon to do sovideo projector when called upon to do so.. While deployableWhile deployable in themselves as an innovative teaching method, teachletsin themselves as an innovative teaching method, teachlets can also be used as a design object in seminarcan also be used as a design object in seminar--like workshoplike workshop eventsevents.. In the course on advanced concepts of objectIn the course on advanced concepts of object-- oriented programming described here, the participantsoriented programming described here, the participants themselves developed and used teachlets in a sothemselves developed and used teachlets in a so--calledcalled teachlet laboratoryteachlet laboratory..
  • 8. 8 Teaching OO MethodologyTeaching OO Methodology in a Project-Driven CS2in a Project-Driven CS2 CourseCourse  Barry Kurtz, Frank Barry, James Wilkes, Appalachian StateBarry Kurtz, Frank Barry, James Wilkes, Appalachian State UniversityUniversity  After we adopted an objects-first approach in CS1, weAfter we adopted an objects-first approach in CS1, we realized this meant redesigning our CS2 and data structuresrealized this meant redesigning our CS2 and data structures courses. This paper reports on our efforts to develop acourses. This paper reports on our efforts to develop a project-driven CS2 course that expands on the object-orientedproject-driven CS2 course that expands on the object-oriented methodology introduced in the CS1 course. We omitted somemethodology introduced in the CS1 course. We omitted some traditional data structures materials, such as pointertraditional data structures materials, such as pointer implementations of linked lists, and concentrated on usingimplementations of linked lists, and concentrated on using Java Collections. Our focus on using data structures inJava Collections. Our focus on using data structures in meaningful, large-scale projects helped students understandmeaningful, large-scale projects helped students understand why these structures are important before concentrating onwhy these structures are important before concentrating on implementation in the subsequent data structures andimplementation in the subsequent data structures and algorithms course.algorithms course.  C. Horstmann, Big Java + W. Savitch, Absolute JavaC. Horstmann, Big Java + W. Savitch, Absolute Java  CS1 Use Blue J, CS2 Dr. JavaCS1 Use Blue J, CS2 Dr. Java
  • 9. 9 Roles of Variables inRoles of Variables in OOPOOP  Petri GerdtPetri Gerdt,, Pauli BycklingPauli Byckling ,, JormaJorma SajaniemiSajaniemi, University of Joensuu,, University of Joensuu,  Roles can be assigned to occurrences of variablesRoles can be assigned to occurrences of variables in programs according to a small number ofin programs according to a small number of patterns of use that are both language- andpatterns of use that are both language- and algorithm-independent. Studies on explicitlyalgorithm-independent. Studies on explicitly teaching roles of variables to novice students haveteaching roles of variables to novice students have shown that roles are an excellent pedagogical toolshown that roles are an excellent pedagogical tool for clarifying the structure and meaning offor clarifying the structure and meaning of programs. This paper describes the results of anprograms. This paper describes the results of an investigation designed to test the understandabilityinvestigation designed to test the understandability and acceptability of the role concept and of theand acceptability of the role concept and of the individual roles in novice-level object-orientedindividual roles in novice-level object-oriented programming.programming.
  • 10. 10 Roles of Variables inRoles of Variables in OOP (cont)OOP (cont)  The investigation consisted of a short tutorial on roles, a briefThe investigation consisted of a short tutorial on roles, a brief training session on assigning roles to variables, a testtraining session on assigning roles to variables, a test evaluating the subjects' ability to assign roles, and a set ofevaluating the subjects' ability to assign roles, and a set of open questions concerning their opinions of roles. Theopen questions concerning their opinions of roles. The responses of 43 computer science educators were analyzed.responses of 43 computer science educators were analyzed. Every role was identified at least by 50% accuracy, and inEvery role was identified at least by 50% accuracy, and in typical uses of variables by 70-100% accuracy. Subjects'typical uses of variables by 70-100% accuracy. Subjects' comments on the role concept in general were mostlycomments on the role concept in general were mostly positive. The role set used in the investigation turned out to bepositive. The role set used in the investigation turned out to be suitable for describing variable usage in novice-levelsuitable for describing variable usage in novice-level programming with some supplements. The study suggestsprogramming with some supplements. The study suggests that more roles are needed in novice-level object-orientedthat more roles are needed in novice-level object-oriented programming than in novice-level procedural programming.programming than in novice-level procedural programming.  http://www.cs.joensuu.fi/~saja/var_roles/http://www.cs.joensuu.fi/~saja/var_roles/
  • 11. 11 Educators' SymposiumEducators' Symposium Keynote:Keynote: Ward CunninghamWard Cunningham  This year, we are honored to have as our keynoteThis year, we are honored to have as our keynote speaker Ward Cunningham. Ward has pioneeredspeaker Ward Cunningham. Ward has pioneered so many of the ideas and tools we all use today:so many of the ideas and tools we all use today: object-oriented programming, CRC cards, patterns,object-oriented programming, CRC cards, patterns, wiki, extreme programming, test-first design, andwiki, extreme programming, test-first design, and FIT. In his talk, Ward will offer some advice for howFIT. In his talk, Ward will offer some advice for how we can recognize good ideas in their humility, howwe can recognize good ideas in their humility, how to nurture good ideas to fruition, and how we mightto nurture good ideas to fruition, and how we might teach these skills in our courses.teach these skills in our courses.  Nurturing the Feeble SimplicityNurturing the Feeble Simplicity
  • 12. 12 Educators' SymposiumEducators' Symposium Teaching ToolsTeaching Tools  This session consists of a paper session and a panel. The papersThis session consists of a paper session and a panel. The papers explore ways that educators are using two of Ward's innovations,explore ways that educators are using two of Ward's innovations, CRC cards and FIT tests, in the classroom. The panel looks to theCRC cards and FIT tests, in the classroom. The panel looks to the future of OO education, in particular seemingly never-ending tug-of-future of OO education, in particular seemingly never-ending tug-of- war around language and programming style in the first-yearwar around language and programming style in the first-year courses. Both of these subsessions will be contain ample time for thecourses. Both of these subsessions will be contain ample time for the authors, panelists, and attendees to discuss the ideas underauthors, panelists, and attendees to discuss the ideas under consideration.consideration.  Improving CRC-Card Role-Play with Role-Play DiagramsImproving CRC-Card Role-Play with Role-Play Diagrams Jürgen BörstlerJürgen Börstler Monday, 15:30, 20 minutes, San Diego RoomMonday, 15:30, 20 minutes, San Diego Room  The Practice of Specifying Requirements UsingThe Practice of Specifying Requirements Using Executable Acceptance Tests in Computer ScienceExecutable Acceptance Tests in Computer Science CoursesCourses Grigori Melnik, Frank MaurerGrigori Melnik, Frank Maurer Monday, 15:50, 20 minutes, San Diego RoomMonday, 15:50, 20 minutes, San Diego Room
  • 13. 13 Improving CRCImproving CRC--Card RoleCard Role-- Play w/ RolePlay w/ Role--PlayPlay DiagramsDiagrams  Jürgen BörstlerJürgen Börstler, Umeä University, Umeä University  CRC cards are a lightweight approach to collaborative objectCRC cards are a lightweight approach to collaborative object--orientedoriented modellingmodelling.. They have been adopted by many educators and trainers to teachThey have been adopted by many educators and trainers to teach early objectearly object--oriented designoriented design.. Reports in the literature are generally positiveReports in the literature are generally positive.. So is our own experienceSo is our own experience.. However, over the years, we have noticed manyHowever, over the years, we have noticed many subtle problems and issues that have largely gone unnoticed in the literaturesubtle problems and issues that have largely gone unnoticed in the literature..  In this paper, we discuss the problems and issues we experienced whenIn this paper, we discuss the problems and issues we experienced when teaching CRC cards to novices. Two major sources of problems can be tracedteaching CRC cards to novices. Two major sources of problems can be traced back to CRC card role play. One is the usage of CRC cards as substitutes forback to CRC card role play. One is the usage of CRC cards as substitutes for actual objects during the scenario role-play and the other the difficulty toactual objects during the scenario role-play and the other the difficulty to document or trace the scenario role-play "on the fly". We propose a new typedocument or trace the scenario role-play "on the fly". We propose a new type of diagram to support the role play activities and to overcome these problems.of diagram to support the role play activities and to overcome these problems. Our experience so far is quite positive. Novices have fewer problems withOur experience so far is quite positive. Novices have fewer problems with role-play activities when using these diagrams. Teaching and learning therole-play activities when using these diagrams. Teaching and learning the new type of diagram adds only little overhead to the overall CRC approach.new type of diagram adds only little overhead to the overall CRC approach.  We also provide general guidelines for CRC card usage. Although ourWe also provide general guidelines for CRC card usage. Although our improvements are aimed at novices, we believe that the proposed diagram isimprovements are aimed at novices, we believe that the proposed diagram is useful even for professional software development.useful even for professional software development.
  • 14. 14 Requirements Using ExecutableRequirements Using Executable Acceptance Tests in CSAcceptance Tests in CS CoursesCourses  The Practice of Specifying Requirements UsingThe Practice of Specifying Requirements Using Executable Acceptance Tests in Computer ScienceExecutable Acceptance Tests in Computer Science CoursesCourses  Grigori MelnikGrigori Melnik ,, Frank MaurerFrank Maurer , University of Calgary, University of Calgary  This report describes the practice of using executableThis report describes the practice of using executable acceptance testing for specifying programming assignmentsacceptance testing for specifying programming assignments in software engineering courses. We summarize experiencesin software engineering courses. We summarize experiences from two courses introduced in two academic institutions overfrom two courses introduced in two academic institutions over four semesters—both from students' and instructors'four semesters—both from students' and instructors' perspectives. Examples of projects and the discussion of theperspectives. Examples of projects and the discussion of the assignment flows are given. The paper highlights testing asassignment flows are given. The paper highlights testing as an all-encompassing activity in software developmentan all-encompassing activity in software development projects. It also contains recommendations for academicsprojects. It also contains recommendations for academics thinking of incorporating executable acceptance testing intothinking of incorporating executable acceptance testing into their courses.their courses.
  • 15. 15 Educators' SymposiumEducators' Symposium Looking to the FutureLooking to the Future  The symposium closes with a panel discussion and an open-The symposium closes with a panel discussion and an open- mike session. The panel looks to the future of OO education,mike session. The panel looks to the future of OO education, in particular seemingly never-ending tug-of-war aroundin particular seemingly never-ending tug-of-war around language and programming style in the first-year courses. Thelanguage and programming style in the first-year courses. The open-mike session session gives participants a chance toopen-mike session session gives participants a chance to share their best teaching ideas and their ideas for futureshare their best teaching ideas and their ideas for future Educators's Symposia.Educators's Symposia.  Are We Doomed? Reframing the DiscussionAre We Doomed? Reframing the Discussion Robert Biddle, Alistair Cockburn, Brian Marick, AlanRobert Biddle, Alistair Cockburn, Brian Marick, Alan O'Callaghan, Eugene Wallingford, moderatorO'Callaghan, Eugene Wallingford, moderator Monday, 16:15, 1 hour, San Diego RoomMonday, 16:15, 1 hour, San Diego Room  Closing SessionClosing Session Eugene WallingfordEugene Wallingford Monday, 17:15, 15 minutes, San Diego RoomMonday, 17:15, 15 minutes, San Diego Room
  • 16. 16 Panel: Are We Doomed?Panel: Are We Doomed? Reframing theReframing the DiscussionDiscussion Robert BiddleRobert Biddle , Carleton University, Carleton University  Alistair CockburnAlistair Cockburn , Humans and Technology, Humans and Technology  Brian MarickBrian Marick , Independent Consultant, Independent Consultant  Alan O'CallaghanAlan O'Callaghan , De Montfort University, De Montfort University  Eugene Wallingford, moderatorEugene Wallingford, moderator , U. of Northern Iowa, U. of Northern Iowa  At universities around the world, interest in computer scienceAt universities around the world, interest in computer science has plummeted. Is this decline part of a cyclical trend, or ahas plummeted. Is this decline part of a cyclical trend, or a reflection of a change in the world in which computingreflection of a change in the world in which computing operates? This panel discussion will discuss the state ofoperates? This panel discussion will discuss the state of computer science education and what we as computercomputer science education and what we as computer science educators can do to redefine university computingscience educators can do to redefine university computing education. The audience will participate in the discussion!education. The audience will participate in the discussion!
  • 17. 17 Panel: Are We Doomed?Panel: Are We Doomed? – some points mentioned– some points mentioned  Teach about design.Teach about design.  Ruby on rails - Rails is a fullRuby on rails - Rails is a full--stack,stack, openopen--source web framework in Rubysource web framework in Ruby for writing realfor writing real--world applicationsworld applications withwith joy and less codejoy and less code than mostthan most frameworks spend doing XML sit-upsframeworks spend doing XML sit-ups – http://www.rubyonrails.com/http://www.rubyonrails.com/ – moviemovie
  • 18. 18 Panel: Are We Doomed?Panel: Are We Doomed? – what to teach?– what to teach?  What do educated people need toWhat do educated people need to know about CS (course by B.know about CS (course by B. Kernighan)Kernighan)  Give students a working project,Give students a working project, replace pieces.replace pieces.  User interaction designUser interaction design  Team work, comm. skillsTeam work, comm. skills  Look at performance arts curriculumLook at performance arts curriculum
  • 19. 19
  • 20. 20 Educators' SymposiumEducators' Symposium Demos and PostersDemos and Posters  A Pattern-based Approach for Introducing Object-Oriented Analysis andA Pattern-based Approach for Introducing Object-Oriented Analysis and Design in Undergraduate CoursesDesign in Undergraduate Courses Haitham HamzaHaitham Hamza  Double Dispatch for Two-Tiered Type CheckingDouble Dispatch for Two-Tiered Type Checking Adair DingleAdair Dingle  Green: A Pedagogically Customizable Round-tripping UML Class DiagramGreen: A Pedagogically Customizable Round-tripping UML Class Diagram Eclipse Plug-inEclipse Plug-in Carl Alphonce, Blake MartinCarl Alphonce, Blake Martin  Implementing Operating Systems the Object-Oriented WayImplementing Operating Systems the Object-Oriented Way Juan Carlos Guzman, Patrick BobbieJuan Carlos Guzman, Patrick Bobbie  KlassroomSwing: A GUI Package for StudentsKlassroomSwing: A GUI Package for Students Dean SandersDean Sanders  Teaching Web Services with WaterTeaching Web Services with Water Matt Kendall, Ed GehringerMatt Kendall, Ed Gehringer  Virtual PC: Letting Your Students Install and Explore Without FearVirtual PC: Letting Your Students Install and Explore Without Fear Joe HummelJoe Hummel  Visual OS: An Object-Oriented Approach to Teaching Operating SystemVisual OS: An Object-Oriented Approach to Teaching Operating System ConceptsConcepts James Hill, Aniruddha GokhaleJames Hill, Aniruddha Gokhale
  • 21. 21 invited speakersinvited speakers  Robert HassRobert Hass  Gerald JayGerald Jay SussmanSussman, Why Programming is, Why Programming is a Good Medium for Expressing Poorlya Good Medium for Expressing Poorly Understood and Sloppily Formulated IdeasUnderstood and Sloppily Formulated Ideas  David P. ReedDavid P. Reed  Martin FowlerMartin Fowler  GradyGrady BoochBooch  Jimmy WalesJimmy Wales, Wikipedia in the Free Culture, Wikipedia in the Free Culture RevolutionRevolution  Mary BethMary Beth RossonRosson
  • 22. 22 invited speakerinvited speaker  CreativityCreativity  Robert HassRobert Hass, Chancellor of The Academy, Chancellor of The Academy of American Poetsof American Poets  safety vs. freedomsafety vs. freedom  memory/ knowledge preservation vs.memory/ knowledge preservation vs. innovationinnovation  vietnamese saying "spit streight up – learnvietnamese saying "spit streight up – learn something"something"  book by Arthur Kestler on creativity??book by Arthur Kestler on creativity??
  • 23. 23 invited speakerinvited speaker  Designing Croquet's TeaTimeDesigning Croquet's TeaTime -- A RealA Real--time, Temporaltime, Temporal Environment for Active ObjectEnvironment for Active Object CooperationCooperation  David P. ReedDavid P. Reed,,  Co-architect of CroquetCo-architect of Croquet
  • 24. 24 invited speakerinvited speaker  Finding Good DesignFinding Good Design  Martin FowlerMartin Fowler, Chief Scientist,, Chief Scientist, ThoughtWorksThoughtWorks
  • 25. 25 Martin FowlerMartin Fowler Martin Fowler was best described by Brian Foote asMartin Fowler was best described by Brian Foote as "an intellectual jackal with good taste in carrion"."an intellectual jackal with good taste in carrion". He's not come up with great languages or tools,He's not come up with great languages or tools, built major companies or found academic success.built major companies or found academic success. He's an author who has struggled withHe's an author who has struggled with understanding what good design might be and howunderstanding what good design might be and how to communicate it. His books on patterns,to communicate it. His books on patterns, refactoring, UML, and agile development reflect thisrefactoring, UML, and agile development reflect this question and his struggles to find an answer. Hequestion and his struggles to find an answer. He hasn't succeeded yet, but is happy to share hishasn't succeeded yet, but is happy to share his current position, lost in a maze of twisty objects, allcurrent position, lost in a maze of twisty objects, all alikealike
  • 26. 26 Martin Fowler:Martin Fowler: Finding Good DesignFinding Good Design  Don’t separate design from ProgrammingDon’t separate design from Programming  Most important principle: avoid duplicationMost important principle: avoid duplication  Separate UI code from all else – imagineSeparate UI code from all else – imagine you need two different UIsyou need two different UIs  Performance problems come from the DBPerformance problems come from the DB  The network is never transparatentThe network is never transparatent  Patterns are a “chunking mechanisms”Patterns are a “chunking mechanisms”  Books should be written so that one doesBooks should be written so that one does not need to read them end to end.not need to read them end to end.
  • 27. 27 invited speakerinvited speaker  On Creating a Handbook ofOn Creating a Handbook of Software ArchitectureSoftware Architecture  Grady BoochGrady Booch, Free Radical, IBM, Free Radical, IBM
  • 28. 28 Grady BoochGrady Booch On Creating a Handbook ofOn Creating a Handbook of Software ArchitectureSoftware Architecture  It is a sign of maturity for any given engineeringIt is a sign of maturity for any given engineering discipline when we can name, study, and apply thediscipline when we can name, study, and apply the patterns relevant to that domain. In civilpatterns relevant to that domain. In civil engineering, chemical engineering, mechanicalengineering, chemical engineering, mechanical engineering, electrical engineering, and now evenengineering, electrical engineering, and now even genomic engineering, there exist libraries ofgenomic engineering, there exist libraries of common patterns that have proven themselvescommon patterns that have proven themselves useful in practice. Unfortunately, no suchuseful in practice. Unfortunately, no such architectural reference yet exists for software-architectural reference yet exists for software- intensive systems. Although the patternsintensive systems. Although the patterns community has pioneered the vocabulary of designcommunity has pioneered the vocabulary of design patterns through the work of the Hillside Group andpatterns through the work of the Hillside Group and the Gang of Four, our industry has no parallel to thethe Gang of Four, our industry has no parallel to the architecture handbooks found in more maturearchitecture handbooks found in more mature design disciplines.design disciplines.
  • 29. 29 Grady BoochGrady Booch On Creating a Handbook ofOn Creating a Handbook of Software ArchitectureSoftware Architecture  Following the work of Bruce Anderson, who over aFollowing the work of Bruce Anderson, who over a decade ago conducted a series of workshops atdecade ago conducted a series of workshops at OOPSLA, I've begun an effort to fill this void inOOPSLA, I've begun an effort to fill this void in software engineering by codifying a the architecturesoftware engineering by codifying a the architecture of a large collection of interesting software-intensiveof a large collection of interesting software-intensive systems, presenting them in a manner that exposessystems, presenting them in a manner that exposes their essential patterns and that permits comparisontheir essential patterns and that permits comparison across domains and architectural styles.across domains and architectural styles.  In this presentation, we'll examine the nature ofIn this presentation, we'll examine the nature of architectural patterns and the process of conductingarchitectural patterns and the process of conducting architectural digs to harvest them, and thenarchitectural digs to harvest them, and then examine a few of the systems studied thus far.examine a few of the systems studied thus far.
  • 30. 30 invited speakerinvited speaker OnwardOnward!! KeynoteKeynote::  The End of UsersThe End of Users  Mary Beth RossonMary Beth Rosson ,,  Pennsylvania State UniversityPennsylvania State University
  • 31. 31 Mary Beth RossonMary Beth Rosson The End of UsersThe End of Users  Over the past 20 years, user interface designersOver the past 20 years, user interface designers and usability engineers have studied and refinedand usability engineers have studied and refined human-computer interaction techniques with thehuman-computer interaction techniques with the goal of improving people's productivity andgoal of improving people's productivity and experience. But the target of these efforts "the end-experience. But the target of these efforts "the end- user" is fast becoming a thing of the past. Manyuser" is fast becoming a thing of the past. Many people now construct software on their own,people now construct software on their own, building artifacts that range from email filters tobuilding artifacts that range from email filters to spreadsheet simulations to interactive webspreadsheet simulations to interactive web applications. These individuals are use-developers:applications. These individuals are use-developers: they build ad hoc solutions to everyday computingthey build ad hoc solutions to everyday computing needs.needs.
  • 32. 32 Mary Beth RossonMary Beth Rosson The End of UsersThe End of Users  Will use-developers help to resolve the software crisis? GivenWill use-developers help to resolve the software crisis? Given the right tools, people and groups may be able to rapidlythe right tools, people and groups may be able to rapidly develop custom solutions to many context-specific computingdevelop custom solutions to many context-specific computing requirements, eliminating the wait for IT professionals torequirements, eliminating the wait for IT professionals to analyze and engineer a solution. Or are these individuals aanalyze and engineer a solution. Or are these individuals a danger to society? Use-developers are informal programmersdanger to society? Use-developers are informal programmers with no training in software construction methods orwith no training in software construction methods or computing paradigms. They have little intrinsic motivation tocomputing paradigms. They have little intrinsic motivation to test their products for even basic concerns like correctness ortest their products for even basic concerns like correctness or safety. In this talk I argue that the transformation of end-usersafety. In this talk I argue that the transformation of end-user to use-developer is well underway and discuss the prospectsto use-developer is well underway and discuss the prospects for maximizing the benefits to society while addressing thefor maximizing the benefits to society while addressing the risks.risks.
  • 33. 33 Research papersResearch papers  Research papers form the heart of the OOPSLA experienceResearch papers form the heart of the OOPSLA experience.. Research papers describe substantiated new research orResearch papers describe substantiated new research or novel technical results, advance the state of the art, or reportnovel technical results, advance the state of the art, or report on significant experience or experimentationon significant experience or experimentation.. The 29 technicalThe 29 technical papers were selected after a rigorous peer review of 142papers were selected after a rigorous peer review of 142 submissions by an international program committee consistingsubmissions by an international program committee consisting of 28 experts representing the spectrum of object technologyof 28 experts representing the spectrum of object technology.. Each paper was assigned to at least three reviewers withEach paper was assigned to at least three reviewers with many reviewed by more, and one by ninemany reviewed by more, and one by nine.. The committee metThe committee met faceface--toto--face for two days in Los Angeles, Californiaface for two days in Los Angeles, California.. TheThe papers selected for presentation at this conference shouldpapers selected for presentation at this conference should advance the state of the art of object technology in significantadvance the state of the art of object technology in significant waysways..
  • 34. 34 Research papersResearch papers  Type TypesType Types  Analysis AnalyzedAnalysis Analyzed  Archetypal ArchitecturesArchetypal Architectures  Language LingoLanguage Lingo  Adaptation AdaptedAdaptation Adapted  Machine MachineryMachine Machinery  Tracing TracesTracing Traces  Concurrency || ConcurrencyConcurrency || Concurrency  Exceptional ExceptionsExceptional Exceptions
  • 35. 35 Research papersResearch papers Type TypesType Types  Associated Types and Constraint PropagaAssociated Types and Constraint Propaga Jaakko Järvi, Jeremiah Willcock, AndrewJaakko Järvi, Jeremiah Willcock, Andrew LumsdaineLumsdaine  Generalized Algebraic Data TypesGeneralized Algebraic Data Types and Object-Oriented Programmingand Object-Oriented Programming Andrew Kennedy, Claudio RussoAndrew Kennedy, Claudio Russo  Scalable Component AbstractionsScalable Component Abstractions Martin Odersky, Matthias ZengerMartin Odersky, Matthias Zenger
  • 36. 36 Associated Types andAssociated Types and Constraint PropagationConstraint Propagation …… Support for object-oriented programming has become an integral partSupport for object-oriented programming has become an integral part of mainstream languages, and more recently generic programmingof mainstream languages, and more recently generic programming has gained widespread acceptance as well. A natural question is howhas gained widespread acceptance as well. A natural question is how these two paradigms, and their underlying language mechanisms,these two paradigms, and their underlying language mechanisms, should interact. One particular design option, that of using subtypingshould interact. One particular design option, that of using subtyping to constrain the type parameters of generic functions, has beento constrain the type parameters of generic functions, has been chosen for the generics extensions to Java and C#. Certainchosen for the generics extensions to Java and C#. Certain shortcomings have previously been identified in using subtyping forshortcomings have previously been identified in using subtyping for constraining parametric polymorphism in the context of genericconstraining parametric polymorphism in the context of generic programming. To address these, we propose the expansion ofprogramming. To address these, we propose the expansion of object-oriented interfaces and subtyping to include associated typesobject-oriented interfaces and subtyping to include associated types and constraint propagation. Associated types are type members ofand constraint propagation. Associated types are type members of interfaces and classes. Constraint propagation allows certaininterfaces and classes. Constraint propagation allows certain constraints on type parameters to be inferred from other constraintsconstraints on type parameters to be inferred from other constraints on those parameters and their use in base class type expressions.on those parameters and their use in base class type expressions. The paper demonstrates these extensions in the context of GenericThe paper demonstrates these extensions in the context of Generic C# and presents a formalism proving their safety. The formalism isC# and presents a formalism proving their safety. The formalism is applicable to other mainstream OO languages supporting F-boundedapplicable to other mainstream OO languages supporting F-bounded polymorphism, such as Java.polymorphism, such as Java.
  • 37. 37 Generalized AlgebraicGeneralized Algebraic Data Types and OOPData Types and OOP  Generalized algebraic data typesGeneralized algebraic data types ((GADTsGADTs)) have receivedhave received much attention recently in the functional programmingmuch attention recently in the functional programming communitycommunity.. They generalize the typeThey generalize the type--parameterizedparameterized datatypes of ML and Haskell by permitting constructors todatatypes of ML and Haskell by permitting constructors to produce different typeproduce different type--instantiations of the same datatypeinstantiations of the same datatype.. GADTs have a number of applications, including stronglyGADTs have a number of applications, including strongly typed evaluators, generic prettytyped evaluators, generic pretty--printing, generic traversalsprinting, generic traversals and queries, and typed LR parsingand queries, and typed LR parsing.. We show that existingWe show that existing objectobject--oriented programming languages such as Java and C#oriented programming languages such as Java and C# can express GADT definitions, and a large class of GADTcan express GADT definitions, and a large class of GADT-- manipulating programs, through the use of generics,manipulating programs, through the use of generics, subclassing, and virtual dispatchsubclassing, and virtual dispatch.. However, some programsHowever, some programs can be written only through the use of redundant runcan be written only through the use of redundant run--timetime castscasts.. We propose a generalization of the type constraintWe propose a generalization of the type constraint mechanisms of C# and Java to avoid the need for such casts,mechanisms of C# and Java to avoid the need for such casts, present a Visitor pattern for GADTs, and describe a switchpresent a Visitor pattern for GADTs, and describe a switch construct as an alternative to virtual dispatch on datatypesconstruct as an alternative to virtual dispatch on datatypes.. We formalize both extensions and prove a type soundnessWe formalize both extensions and prove a type soundness resultresult..
  • 38. 38 Scalable ComponentScalable Component AbstractionsAbstractions  We identify three programming languageWe identify three programming language abstractions for the construction of reusableabstractions for the construction of reusable componentscomponents:: abstract type members, explicitabstract type members, explicit selftypes, and symmetric mixin compositionselftypes, and symmetric mixin composition.. Together, these abstractions enable us to transformTogether, these abstractions enable us to transform an arbitrary assembly of static program parts withan arbitrary assembly of static program parts with hard references between them into a system ofhard references between them into a system of reusable componentsreusable components.. The transformationThe transformation maintains the structure of the original systemmaintains the structure of the original system.. WeWe demonstrate this approach in two case studies, ademonstrate this approach in two case studies, a subjectsubject//observer framework and a compiler frontobserver framework and a compiler front-- endend..  Scala languageScala language
  • 39. 39 Research papersResearch papers Analysis AnalyzedAnalysis Analyzed  Demand-Driven Points-to Analysis for JavDemand-Driven Points-to Analysis for Jav Manu Sridharan, Denis Gopan, Lexin Shan,Manu Sridharan, Denis Gopan, Lexin Shan, Rastislav BodikRastislav Bodik  Deriving ObjectDeriving Object TypestatesTypestates in the Presence of Inter-Object Referencin the Presence of Inter-Object Referenc Mangala Gowri Nanda, Christian Grothoff,Mangala Gowri Nanda, Christian Grothoff, Satish ChandraSatish Chandra  Micro Patterns in Java CodeMicro Patterns in Java Code Joseph (Yossi) Gil, Itay MamanJoseph (Yossi) Gil, Itay Maman
  • 40. 40 Research papersResearch papers Archetypal ArchitecturesArchetypal Architectures  ArchMatEArchMatE : From Architectural Styles to Object-Oriented Models thro: From Architectural Styles to Object-Oriented Models thro J. Andrés Díaz Pace, Marcelo R. CampoJ. Andrés Díaz Pace, Marcelo R. Campo  Modeling Architectural Patterns Using Architectural PrimitModeling Architectural Patterns Using Architectural Primit Uwe Zdun, Paris AvgeriouUwe Zdun, Paris Avgeriou  Parametric Polymorphism for Software Component ArchiteParametric Polymorphism for Software Component Archite Cosmin Oancea, Stephen WattCosmin Oancea, Stephen Watt  Using Dependency Models to Manage Complex Software AUsing Dependency Models to Manage Complex Software A Neeraj Sangal, Ev Jordan, Vineet Sinha, Daniel JacksonNeeraj Sangal, Ev Jordan, Vineet Sinha, Daniel Jackson
  • 41. 41 Research papersResearch papers Language LingoLanguage Lingo  ClassboxClassbox /J: Controlling the Scope of Change in Ja/J: Controlling the Scope of Change in Ja Alexandre Bergel, Stéphane Ducasse,Alexandre Bergel, Stéphane Ducasse, Oscar NierstraszOscar Nierstrasz  Interaction-Based Programming withInteraction-Based Programming with ClassagesClassages Yu David Liu, Scott SmithYu David Liu, Scott Smith  Javari: Adding ReferenceJavari: Adding Reference Immutability to JavaImmutability to Java Matthew S. Tschantz, Michael D. ErnstMatthew S. Tschantz, Michael D. Ernst
  • 42. 42 ClassboxClassbox//JJ:: Controlling theControlling the Scope of Change in JavaScope of Change in Java  Unanticipated changes to complex software systems can introduceUnanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritanceanomalies such as duplicated code, suboptimal inheritance relationships and a proliferation of runrelationships and a proliferation of run--time downcaststime downcasts.. Refactoring toRefactoring to eliminate these anomalies may not be an option, at least in certaineliminate these anomalies may not be an option, at least in certain stages of software evolutionstages of software evolution.. Classboxes are modules that restrictClassboxes are modules that restrict the visibility of changes to selected clients only, thereby offering morethe visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, andfreedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomaliesthus reducing the need for convoluted design anomalies.. In thisIn this paper we demonstrate how classboxes can be implemented inpaper we demonstrate how classboxes can be implemented in staticallystatically--typed languages like Javatyped languages like Java.. We also present an extendedWe also present an extended case study of Swing, a Java GUI package built on top of AWT, andcase study of Swing, a Java GUI package built on top of AWT, and we document the ensuing anomalies that Swing introduceswe document the ensuing anomalies that Swing introduces.. We showWe show how Classboxhow Classbox//J, a prototype implementation of classboxes for Java,J, a prototype implementation of classboxes for Java, is used to provide a cleaner implementation of Swing using localis used to provide a cleaner implementation of Swing using local refinement rather than subclassingrefinement rather than subclassing..
  • 43. 43 Javari: AddingJavari: Adding Reference ImmutabilityReference Immutability to Javato Java This paper describes a type system that is capable of expressing andThis paper describes a type system that is capable of expressing and enforcing immutability constraintsenforcing immutability constraints.. The specific constraint expressedThe specific constraint expressed is that the abstract state of the object to which an immutableis that the abstract state of the object to which an immutable reference refers cannot be modified using that referencereference refers cannot be modified using that reference.. TheThe abstract state isabstract state is ((part ofpart of)) the transitively reachable statethe transitively reachable state:: that is, thethat is, the state of the object and all state reachable from it by followingstate of the object and all state reachable from it by following referencesreferences.. The type system permits explicitly excluding fields orThe type system permits explicitly excluding fields or objects from the abstract state of an objectobjects from the abstract state of an object.. For a statically typeFor a statically type--safesafe language, the type system guarantees reference immutabilitylanguage, the type system guarantees reference immutability.. If theIf the language is extended with immutability downcasts, then runlanguage is extended with immutability downcasts, then run--timetime checks enforce the reference immutability constraintschecks enforce the reference immutability constraints.. This researchThis research builds upon a previous research in language support for referencebuilds upon a previous research in language support for reference immutabilityimmutability.. Improvements that are new in this paper includeImprovements that are new in this paper include distinguishing the notions of assignability and mutability; integrationdistinguishing the notions of assignability and mutability; integration with Java 5's generic types and with multiwith Java 5's generic types and with multi--dimensional arrays; adimensional arrays; a mutability polymorphism approach to avoiding code duplication; typemutability polymorphism approach to avoiding code duplication; type-- safe support for reflection and serialization; and formal type rules forsafe support for reflection and serialization; and formal type rules for a core calculusa core calculus.. Furthermore, it retains the valuable features of theFurthermore, it retains the valuable features of the previous dialect, including usability by humansprevious dialect, including usability by humans ((as evidenced byas evidenced by experience with 160,000 lines of Javari codeexperience with 160,000 lines of Javari code)) and interoperability withand interoperability with Java and existing JVMsJava and existing JVMs..
  • 44. 44 Research papersResearch papers Adaptation AdaptedAdaptation Adapted  Fine-Grained Interoperability through MirrFine-Grained Interoperability through Mirr Kathryn Gray, Robert Findler, Matthew FlattKathryn Gray, Robert Findler, Matthew Flatt  Pluggable AOP: Designing AspectPluggable AOP: Designing Aspect Mechanisms for Third-partyMechanisms for Third-party CompositionComposition Sergei Kojarski, David LorenzSergei Kojarski, David Lorenz  Refactoring Support for Class LibraryRefactoring Support for Class Library MigrationMigration Ittai Balaban, Frank Tip, Robert FuhrerIttai Balaban, Frank Tip, Robert Fuhrer
  • 45. 45 Pluggable AOPPluggable AOP:: DesigningDesigning Aspect Mechanisms forAspect Mechanisms for ThirdThird--party Compositionparty Composition  Studies of AspectStudies of Aspect--Oriented ProgrammingOriented Programming ((AOPAOP)) usually focus on a language in which a specificusually focus on a language in which a specific aspect extension is integrated with a baseaspect extension is integrated with a base languagelanguage.. Languages specified in this manner haveLanguages specified in this manner have a fixed, nona fixed, non--extensible AOP functionalityextensible AOP functionality.. In thisIn this paper we consider the more general case ofpaper we consider the more general case of integrating a base language with a set of domainintegrating a base language with a set of domain specific thirdspecific third--party aspect extensions for thatparty aspect extensions for that languagelanguage.. We present a general mixinWe present a general mixin--basedbased method for implementing aspect extensions in suchmethod for implementing aspect extensions in such a way that multiple, independently developed,a way that multiple, independently developed, dynamic aspect extensions can be subject to thirddynamic aspect extensions can be subject to third-- party composition and work collaborativelyparty composition and work collaboratively..
  • 46. 46 Refactoring Support forRefactoring Support for Class Library MigrationClass Library Migration  As objectAs object--oriented class libraries evolve, classes areoriented class libraries evolve, classes are occasionally deprecated in favor of others with roughly theoccasionally deprecated in favor of others with roughly the same functionalitysame functionality.. In Java's standard libraries, for example,In Java's standard libraries, for example, class Hashtable has been superseded by HashMap, andclass Hashtable has been superseded by HashMap, and Iterator is now preferred over EnumerationIterator is now preferred over Enumeration..  Migrating client applications to use the new idioms is oftenMigrating client applications to use the new idioms is often desirable, but making the required changes to declarationsdesirable, but making the required changes to declarations and allocation sites can be quite labor-intensive. Moreover,and allocation sites can be quite labor-intensive. Moreover, migration becomes complicated—and sometimes impossiblemigration becomes complicated—and sometimes impossible —if an application interacts with external components, if a—if an application interacts with external components, if a deprecated class is not completely equivalent to itsdeprecated class is not completely equivalent to its replacement, and if multiple interdependent types must bereplacement, and if multiple interdependent types must be migrated simultaneously.migrated simultaneously.
  • 47. 47 Refactoring Support forRefactoring Support for Class Library MigrationClass Library Migration (cont.)(cont.)  We present an approach in which mappingsWe present an approach in which mappings between legacy types and their replacements arebetween legacy types and their replacements are specified by the programmer. Then, an analysisspecified by the programmer. Then, an analysis based on type constraints determines wherebased on type constraints determines where declarations and allocation sites can be updated.declarations and allocation sites can be updated. The method was implemented in Eclipse, andThe method was implemented in Eclipse, and evaluated on a number of Java applications. Onevaluated on a number of Java applications. On average, our tool could migrate more than 90% ofaverage, our tool could migrate more than 90% of the references to legacy types in thesethe references to legacy types in these benchmarks.benchmarks.
  • 48. 48 Research papersResearch papers Machine MachineryMachine Machinery  Automating Vertical ProfilingAutomating Vertical Profiling Matthias Hauswirth, Amer Diwan, Peter Sweeney,Matthias Hauswirth, Amer Diwan, Peter Sweeney, Michael MozerMichael Mozer  Improving Virtual Machine PerformanceImproving Virtual Machine Performance Using a Cross-Run RepositoryUsing a Cross-Run Repository Matthew Arnold, Adam Welc, V.T. RajanMatthew Arnold, Adam Welc, V.T. Rajan  Quantifying the Performance of GarbageQuantifying the Performance of Garbage Collection vs. Explicit Memory ManagementCollection vs. Explicit Memory Management Matthew Hertz, Emery BergerMatthew Hertz, Emery Berger  Runtime Specialization With OptimisticRuntime Specialization With Optimistic Heap AnalysisHeap Analysis Ajeet Shankar, Rastislav Bodik, SubramanyaAjeet Shankar, Rastislav Bodik, Subramanya Sastry, James SmithSastry, James Smith
  • 49. 49 Garbage Collection vsGarbage Collection vs .. Explicit MemoryExplicit Memory ManagemntManagemnt  Garbage collection yields numerous softwareGarbage collection yields numerous software engineering benefits, but its quantitative impact onengineering benefits, but its quantitative impact on performance remains elusiveperformance remains elusive.. One can measure theOne can measure the cost of conservative garbage collection relative tocost of conservative garbage collection relative to explicit memory management in Cexplicit memory management in C//CC++++ programsprograms by linking in an appropriate collectorby linking in an appropriate collector.. This kind ofThis kind of direct comparison is not possible for languagesdirect comparison is not possible for languages designed for garbage collectiondesigned for garbage collection ((ee..gg.., Java, Java)),, because programs in these languages naturally dobecause programs in these languages naturally do not contain calls to freenot contain calls to free.. Thus, the actual gapThus, the actual gap between the timebetween the time--space performance of explicitspace performance of explicit memory management and precise, copyingmemory management and precise, copying garbage collection remains unknowngarbage collection remains unknown..
  • 50. 50 Garbage Collection vsGarbage Collection vs .. Explct Mem MngemntExplct Mem Mngemnt (cont)(cont)  We take the first steps towards quantifying the performance ofWe take the first steps towards quantifying the performance of precise garbage collection versus explicit memoryprecise garbage collection versus explicit memory management. We present a novel experimental methodologymanagement. We present a novel experimental methodology that lets us treat unaltered Java programs as if they usedthat lets us treat unaltered Java programs as if they used explicit memory management. Our system generates exactexplicit memory management. Our system generates exact object reachability information by processing heap traces withobject reachability information by processing heap traces with the Merlin algorithm. It then re-executes the program, invokingthe Merlin algorithm. It then re-executes the program, invoking free on objects just before they become unreachable. Sincefree on objects just before they become unreachable. Since this point is the latest that a programmer could explicitly freethis point is the latest that a programmer could explicitly free objects, our approach conservatively approximates explicitobjects, our approach conservatively approximates explicit memory management. By executing inside an architecturally-memory management. By executing inside an architecturally- detailed simulator, this ``oracular'' memory managerdetailed simulator, this ``oracular'' memory manager eliminates the effects of trace processing while measuring theeliminates the effects of trace processing while measuring the costs of calling malloc and free.costs of calling malloc and free.
  • 51. 51 Garbage Collection vsGarbage Collection vs .. Explct Mem MngemntExplct Mem Mngemnt (cont)(cont)  We compare explicit memory management to both copyingWe compare explicit memory management to both copying and non-copying garbage collectors across a range ofand non-copying garbage collectors across a range of benchmarks, and include non-simulated runs that validate ourbenchmarks, and include non-simulated runs that validate our results. Our results quantify the time-space tradeoff ofresults. Our results quantify the time-space tradeoff of garbage collection: with five times as much memory, thegarbage collection: with five times as much memory, the Appel-style generational garbage collector matches theAppel-style generational garbage collector matches the performance of explicit memory management. With only threeperformance of explicit memory management. With only three times as much memory, it runs on average 17% slower thantimes as much memory, it runs on average 17% slower than explicit memory management. However, with only twice asexplicit memory management. However, with only twice as much memory, garbage collection degrades performance bymuch memory, garbage collection degrades performance by nearly 70%. When physical memory is scarce, paging causesnearly 70%. When physical memory is scarce, paging causes garbage collection to run an order of magnitude slower thangarbage collection to run an order of magnitude slower than explicit memory management.explicit memory management.
  • 52. 52 Runtime SpecializationRuntime Specialization With Optimistic HeapWith Optimistic Heap AnalysisAnalysis  Runtime specialization is an optimization process that can provideRuntime specialization is an optimization process that can provide significant speedups by exploiting a program's runtime statesignificant speedups by exploiting a program's runtime state.. ExistingExisting specializers employ a staged model that statically identifiesspecializers employ a staged model that statically identifies specialization code regions and constant heap locations, and thenspecialization code regions and constant heap locations, and then optimizes them at runtime once the constants are knownoptimizes them at runtime once the constants are known.. This paperThis paper describes a dynamic program specializer that is transparent, anddescribes a dynamic program specializer that is transparent, and thus does not require any static components such as programmerthus does not require any static components such as programmer annotations or preannotations or pre--runtime analysisruntime analysis.. The specializer usesThe specializer uses ((11)) a novela novel store profile to identify constant heap locations that a staged systemstore profile to identify constant heap locations that a staged system cannot, such as constants present in an interpreted programcannot, such as constants present in an interpreted program.. ThisThis information is used in tandem withinformation is used in tandem with ((22)) a new algorithm for findinga new algorithm for finding specialization starting points based on a notion of influence to createspecialization starting points based on a notion of influence to create specializationsspecializations. (. (33)) An automatic invalidation transformationAn automatic invalidation transformation efficiently monitors assumptions about heap constants, and is able toefficiently monitors assumptions about heap constants, and is able to deactivate specialized traces even if they are on the stackdeactivate specialized traces even if they are on the stack.. AnAn implementation of the specializer in Jikes RVM has low overhead inimplementation of the specializer in Jikes RVM has low overhead in practice, selects specialization points that would be chosen manually,practice, selects specialization points that would be chosen manually, and produces speedups of 1.2x to 6.3x on a variety of benchmarksand produces speedups of 1.2x to 6.3x on a variety of benchmarks..
  • 53. 53 Research papersResearch papers Tracing TracesTracing Traces  Adding Trace Matching with Free Variables toAdding Trace Matching with Free Variables to AspectJAspectJ Chris Allan, Pavel Avgustinov, Aske SimonChris Allan, Pavel Avgustinov, Aske Simon Christensen, Laurie Hendren, Sascha Kuzins,Christensen, Laurie Hendren, Sascha Kuzins, Ondrej Lhoták, Oege de Moor, Damien Sereni,Ondrej Lhoták, Oege de Moor, Damien Sereni, Ganesh Sittampalam, Julian TibbleGanesh Sittampalam, Julian Tibble  Finding Application Errors Using PQL: AFinding Application Errors Using PQL: A Program Query LanguageProgram Query Language Michael Martin, Benjamin Livshits, Monica LamMichael Martin, Benjamin Livshits, Monica Lam  Relational Queries Over Program TracesRelational Queries Over Program Traces Simon Goldsmith, Robert O'Callahan, Alex AikenSimon Goldsmith, Robert O'Callahan, Alex Aiken
  • 54. 54 Research papersResearch papers Concurrency || ConcurrencyConcurrency || Concurrency  FormalisingFormalising Java RMI with Explicit Code MobilityJava RMI with Explicit Code Mobility Alexander Ahern, Nobuko YoshidaAlexander Ahern, Nobuko Yoshida  Lifting Sequential Graph AlgorithmsLifting Sequential Graph Algorithms for Distributed-Memory Parallelfor Distributed-Memory Parallel ComputationComputation Douglas Gregor, Andrew LumsdaineDouglas Gregor, Andrew Lumsdaine  Safe Futures for JavaSafe Futures for Java Adam Welc, Suresh Jagannathan, AntonyAdam Welc, Suresh Jagannathan, Antony HoskingHosking
  • 55. 55 Research papersResearch papers Exceptional ExceptionsExceptional Exceptions  Combining the Robustness of Checked ExceptioCombining the Robustness of Checked Exceptio Marko van Dooren, Eric SteegmansMarko van Dooren, Eric Steegmans  Incrementalization Across ObjectIncrementalization Across Object AbstractionAbstraction Annie Liu, Scott Stoller, Michael Gorbovitski, TomAnnie Liu, Scott Stoller, Michael Gorbovitski, Tom Rothamel, Yanni LiuRothamel, Yanni Liu  PolyD: A Flexible Dispatching FrameworkPolyD: A Flexible Dispatching Framework Antonio Cunei, Jan VitekAntonio Cunei, Jan Vitek
  • 56. 56 …… Anchored ExceptionAnchored Exception DeclarationsDeclarations  Combining the Robustness of CheckedCombining the Robustness of Checked Exceptions with the Flexibility ofExceptions with the Flexibility of Unchecked Exceptions using AnchoredUnchecked Exceptions using Anchored Exception DeclarationsException Declarations  Ever since their invention 30 years ago,Ever since their invention 30 years ago, checked exceptions have been a point ofchecked exceptions have been a point of much discussionmuch discussion .. On the one hand, theyOn the one hand, they increase the robustness of software byincrease the robustness of software by preventing the manifestation ofpreventing the manifestation of unanticipated checked exceptions at rununanticipated checked exceptions at run -- timetime.. On the other hand, they decrease theOn the other hand, they decrease the adaptability of software because they mustadaptability of software because they must be propagated explicitly, and must often bebe propagated explicitly, and must often be handled even if they cannot be signalledhandled even if they cannot be signalled ..
  • 57. 57 …… Anchored ExceptionAnchored Exception DeclarationsDeclarations  We show that the problems with checked exceptionsWe show that the problems with checked exceptions are caused by a lack of expressiveness of theare caused by a lack of expressiveness of the exceptional return type of a method, which currentlyexceptional return type of a method, which currently dictates a copy & paste style. We add the requireddictates a copy & paste style. We add the required expressiveness by introducing anchored exceptionexpressiveness by introducing anchored exception declarations, which allow the exceptional behaviordeclarations, which allow the exceptional behavior of a method to be declared relative to that of others.of a method to be declared relative to that of others. We present the formal semantics of anchoredWe present the formal semantics of anchored exception declarations, along with the necessaryexception declarations, along with the necessary rules for ensuring compile-time safety, and give arules for ensuring compile-time safety, and give a proof of soundness. We show that anchoredproof of soundness. We show that anchored exception declarations do not violate the principle ofexception declarations do not violate the principle of information hiding when used properly, and provideinformation hiding when used properly, and provide a guideline for when to use them.a guideline for when to use them.  We have implemented anchored exceptionWe have implemented anchored exception declarations in Cappuccino, which is an extension todeclarations in Cappuccino, which is an extension to the ClassicJava programming language.the ClassicJava programming language.
  • 58. 58 IncrementalizationIncrementalization Across ObjectAcross Object AbstractionAbstraction  Object abstraction supports the separation of whatObject abstraction supports the separation of what operations are provided by systems andoperations are provided by systems and components from how the operations arecomponents from how the operations are implemented, and is essential in enabling theimplemented, and is essential in enabling the construction of complex systems from componentsconstruction of complex systems from components.. Unfortunately, clear and modular implementationsUnfortunately, clear and modular implementations have poor performance when expensive queryhave poor performance when expensive query operations are repeated, while efficientoperations are repeated, while efficient implementations that incrementally maintain theseimplementations that incrementally maintain these query results are much more difficult to develop andquery results are much more difficult to develop and to understand, because the code blows upto understand, because the code blows up significantly and is no longer clear or modularsignificantly and is no longer clear or modular..
  • 59. 59 IncrementalizationIncrementalization Across ObjectAcross Object Abstraction (cont)Abstraction (cont) This paper describes a powerful and systematic method thatThis paper describes a powerful and systematic method that first allows the "what" of each component to be specified in afirst allows the "what" of each component to be specified in a clear and modular fashion and implemented straightforwardlyclear and modular fashion and implemented straightforwardly in an object-oriented language; then analyzes the queries andin an object-oriented language; then analyzes the queries and updates, across object abstraction, in the straightforwardupdates, across object abstraction, in the straightforward implementation; and finally derives the sophisticated andimplementation; and finally derives the sophisticated and efficient "how" of each component by incrementallyefficient "how" of each component by incrementally maintaining the results of repeated expensive queries withmaintaining the results of repeated expensive queries with respect to updates to their parameters. Our implementationrespect to updates to their parameters. Our implementation and experimental results for example applications in queryand experimental results for example applications in query optimization, role-based access control, etc. demonstrate theoptimization, role-based access control, etc. demonstrate the effectiveness and benefit of the method.effectiveness and benefit of the method.  (??) Can this be done with aspects?? Topic for MS???(??) Can this be done with aspects?? Topic for MS??? Examples for classes ???Examples for classes ???
  • 60. 60 PolyDPolyD:: A FlexibleA Flexible Dispatching FrameworkDispatching Framework  The standard dispatching mechanisms built into programmingThe standard dispatching mechanisms built into programming languages are sometimes inadequate to the needs of thelanguages are sometimes inadequate to the needs of the programmerprogrammer.. In the case of Java, the need for more flexibilityIn the case of Java, the need for more flexibility has led to the development of a number of tools, includinghas led to the development of a number of tools, including visitors and multivisitors and multi--method extensions, that each add somemethod extensions, that each add some particular functionality, but lack the generality necessary toparticular functionality, but lack the generality necessary to support usersupport user--defined dispatching mechanismsdefined dispatching mechanisms.. In this paperIn this paper we advocate a more modular approach to dispatching, and wewe advocate a more modular approach to dispatching, and we present a tool, PolyD, that allows the programmer to designpresent a tool, PolyD, that allows the programmer to design custom dispatching strategies and to parametrize manycustom dispatching strategies and to parametrize many aspects of the dispatching processaspects of the dispatching process.. PolyD exhibits excellentPolyD exhibits excellent performance and compares well against existing toolsperformance and compares well against existing tools..
  • 61. 61 PanelsPanels  Aspects: Passing Fad or New Foundation?Aspects: Passing Fad or New Foundation? Steve Berczuk (Chair), Matthew Webster, Jack Greenfield, IvarSteve Berczuk (Chair), Matthew Webster, Jack Greenfield, Ivar Jacobson, Gregor Kiczales, Dave ThomasJacobson, Gregor Kiczales, Dave Thomas  Fostering Software Robustness in an Increasingly Hostile WorldFostering Software Robustness in an Increasingly Hostile World Steven Fraser (Chair), Djenana Campara, Carl Chilley, RichardSteven Fraser (Chair), Djenana Campara, Carl Chilley, Richard Gabriel, Ricardo Lopez, Dave Thomas, Greg UtasGabriel, Ricardo Lopez, Dave Thomas, Greg Utas  The Agile PanelThe Agile Panel Linda Rising (Chair), Mary Lynn Manns (Chair), Angela Martin, KevlinLinda Rising (Chair), Mary Lynn Manns (Chair), Angela Martin, Kevlin Henney, Alan O'Callaghan, Rebecca Wirfs-BrockHenney, Alan O'Callaghan, Rebecca Wirfs-Brock  Echoes: Structured Design and Modern Software PracticesEchoes: Structured Design and Modern Software Practices Steven Fraser (Chair), Kent Beck, Grady Booch, Larry Constantine,Steven Fraser (Chair), Kent Beck, Grady Booch, Larry Constantine, Brian Henderson-Sellers, Steve McConnell, Rebecca Wirfs-Brock, EdBrian Henderson-Sellers, Steve McConnell, Rebecca Wirfs-Brock, Ed YourdonYourdon  Living With Legacy: Love It or Leave It?Living With Legacy: Love It or Leave It? Steve Berczuk (Chair), Steven Fraser, Bill Opdyke, Michael Feathers,Steve Berczuk (Chair), Steven Fraser, Bill Opdyke, Michael Feathers, Dennis ManclDennis Mancl
  • 62. 62 Panel - AspectsPanel - Aspects:: Passing FadPassing Fad or New Foundation?or New Foundation?  Matthew WebsterMatthew Webster, IBM, IBM Jack GreenfieldJack Greenfield, Microsoft Corporation, Microsoft Corporation Ivar JacobsonIvar Jacobson, Ivar Jacobson International & Jaczone, Ivar Jacobson International & Jaczone Gregor KiczalesGregor Kiczales, University of British Columbia, University of British Columbia Dave ThomasDave Thomas, Bedarra Research Labs, Carleton University, University of, Bedarra Research Labs, Carleton University, University of QueenslandQueensland  Aspect-oriented software development (AOSD) has a lot of interest in theAspect-oriented software development (AOSD) has a lot of interest in the research community. It has also found early adopters in applicationresearch community. It has also found early adopters in application development and middleware. This panel discusses the potential expansiondevelopment and middleware. This panel discusses the potential expansion and use of AOP into mainstream software development.and use of AOP into mainstream software development.  This question is not just directed to the aspect research community, but alsoThis question is not just directed to the aspect research community, but also to practicing software development teams and organizations. The panel willto practicing software development teams and organizations. The panel will explore the appropriate position and awareness of aspect-orientation amidstexplore the appropriate position and awareness of aspect-orientation amidst other advances in software engineering; how to prepare organizations forother advances in software engineering; how to prepare organizations for adoption; and what additional research and development is necessary. Theadoption; and what additional research and development is necessary. The panel discussion will help the OO community to understand the appropriatepanel discussion will help the OO community to understand the appropriate use of aspect-orientation. It will also highlight areas where additional effortsuse of aspect-orientation. It will also highlight areas where additional efforts by AOSD researchers and professionals are required.by AOSD researchers and professionals are required.
  • 63. 63 PanelPanel  The Agile PanelThe Agile Panel Linda Rising (Chair), Mary LynnLinda Rising (Chair), Mary Lynn Manns (Chair), Angela Martin, KevlinManns (Chair), Angela Martin, Kevlin Henney, Alan O'Callaghan, RebeccaHenney, Alan O'Callaghan, Rebecca Wirfs-BrockWirfs-Brock
  • 64. 64 PanelPanel  Echoes: Structured Design and ModEchoes: Structured Design and Mode Steven Fraser (Chair), Kent Beck,Steven Fraser (Chair), Kent Beck, Grady Booch, Larry Constantine, BrianGrady Booch, Larry Constantine, Brian Henderson-Sellers, Steve McConnell,Henderson-Sellers, Steve McConnell, Rebecca Wirfs-Brock, Ed YourdonRebecca Wirfs-Brock, Ed Yourdon
  • 65. 65 Panel on StructuredPanel on Structured DesignDesign  Echoes: Structured Design and Modern SoftwareEchoes: Structured Design and Modern Software PracticesPractices  Rebecca Wirfs-BrockRebecca Wirfs-Brock  Brian HendersonBrian Henderson  Larry ConstantineLarry Constantine  Ed YourdonEd Yourdon  Kent BeckKent Beck  Grady BoochGrady Booch  chaired by Steven Fraser, Qualcommchaired by Steven Fraser, Qualcomm  Link toLink to WikiWiki
  • 66. 66 PanelPanel  Living With Legacy: Love It or LeaveLiving With Legacy: Love It or Leave Steve Berczuk (Chair), Steven Fraser,Steve Berczuk (Chair), Steven Fraser, Bill Opdyke, Michael Feathers, DennisBill Opdyke, Michael Feathers, Dennis ManclMancl
  • 67. 67 Practitioner ReportsPractitioner Reports  Removing duplication from javaRemoving duplication from java..ioio:: aa case study using Traitscase study using Traits  Emerson MurphyEmerson Murphy--HillHill,, PhilipPhilip QuitslundQuitslund,,Andrew BlackAndrew Black, Portland, Portland State UniversityState University
  • 68. 68 Removing duplication fromRemoving duplication from javajava..ioio:: a case study usinga case study using TraitsTraits  Code duplication is a serious problem with no easyCode duplication is a serious problem with no easy solution, even in industrial-strength code. Singlesolution, even in industrial-strength code. Single inheritance cannot provide for effective code reuseinheritance cannot provide for effective code reuse in all situations, and sometimes programmers arein all situations, and sometimes programmers are driven to duplicate code using copy and paste. Adriven to duplicate code using copy and paste. A language feature called traits enables code to belanguage feature called traits enables code to be shared across the inheritance hierarchy, and claimsshared across the inheritance hierarchy, and claims to permit the removal of most duplication. Weto permit the removal of most duplication. We attempted to validate this claim in a case study ofattempted to validate this claim in a case study of the java.io library. Detecting duplication was morethe java.io library. Detecting duplication was more complex than we had imagined, but traits werecomplex than we had imagined, but traits were indeed able to remove all that we found.indeed able to remove all that we found.
  • 69. 69 Demos: PatternStudioDemos: PatternStudio -- A NewA New Tool for Design PatternTool for Design Pattern ManagementManagement  While design patterns have been widely accepted as best practices in designWhile design patterns have been widely accepted as best practices in design for a decade, their use is still limited owing to lack of a flexible supporting toolfor a decade, their use is still limited owing to lack of a flexible supporting tool.. Many tools are built; however, they have technical restrictions that limit theirMany tools are built; however, they have technical restrictions that limit their use at largeuse at large.. For example, they require developers to use a builtFor example, they require developers to use a built--inin programming language, which may not suit the developers' skills andprogramming language, which may not suit the developers' skills and preferencespreferences.. They use nonThey use non--standard serialization techniques; as a result,standard serialization techniques; as a result, developers cannot exchange patterns freely across different platformsdevelopers cannot exchange patterns freely across different platforms.. Lastly,Lastly, they are not designed to be easily extendable; developers cannot make anythey are not designed to be easily extendable; developers cannot make any enhancement to match their needsenhancement to match their needs.. We have developed a tool that supportsWe have developed a tool that supports design patterns, called PatternStudio, as proposed in our OOPSLA'04 posterdesign patterns, called PatternStudio, as proposed in our OOPSLA'04 poster.. The tool is an integrated environment specially designed to be languageThe tool is an integrated environment specially designed to be language-- neutralneutral ((multiple code templates can be supplied to generate code in differentmultiple code templates can be supplied to generate code in different languageslanguages).). It supports pattern interchangeIt supports pattern interchange ((patterns are serialized in the XMLpatterns are serialized in the XML Metadata Interchange formatMetadata Interchange format)) and it is extendableand it is extendable ((the tool itself is an Eclipsethe tool itself is an Eclipse plugplug--in and can be further extendedin and can be further extended).). Moreover, the tool implements theMoreover, the tool implements the concept of design verification; it checks whether a derivative model conformsconcept of design verification; it checks whether a derivative model conforms to its originated patternto its originated pattern.. In this demonstration, we will describe how the tool isIn this demonstration, we will describe how the tool is created from open technologies ecreated from open technologies e..gg.. Eclipse Modeling FrameworkEclipse Modeling Framework ((EMFEMF)),, Graphical Editing FrameworkGraphical Editing Framework ((GEFGEF)), Java Emitter Templates, Java Emitter Templates ((JETJET)), and XML, and XML SchemaSchema ((XSDXSD)) and show how to work with patterns eand show how to work with patterns e..gg.. define a new pattern,define a new pattern, verify a model against a pattern, and generate pattern code in differentverify a model against a pattern, and generate pattern code in different languageslanguages.. Also, we will explain how developers can make enhancement byAlso, we will explain how developers can make enhancement by extending the toolextending the tool..
  • 70. 70 Other eventsOther events  10 years of Sun10 years of Sun  2020thth OOPSLAOOPSLA
  • 71. 71 SourcesSources  httphttp://://wikiwiki..cscs..uiucuiuc..eduedu//OOPSLA05OOPSLA05  http://www.oopsla.org/2005/http://www.oopsla.org/2005/