| 
            
              
            
                
              
            
            
         
             
        
           | 
          
          
  
  
  
    
    
      
    
                    
                    
                    
                    
                    
                    
                      | 
                        
                          <<< Previous speaker
                        
                       | 
                      
                        
                          next speaker >>>
                        
                       | 
                     
                     
                     
            
  
    
    
  
  
 Brian  Goetz, Author of "Java Concurrency in Practice"
  
     
  
  Brian Goetz has been a professional software developer for 20 years. He is the 
author of the best-selling book "Java Concurrency In Practice", as well as 
over 75 articles on software development.  He is a frequent presenter at major 
industry conferences, and serves on numerous JCP expert groups.  Brian is a 
Sr. Staff Engineer at Sun Microsystems.
 
 
     
  
     
     
   | 
  
    
    
      
                    
                      Presentation: "The Concurrency Revolution: The Hardware Story"
                      
                      
                      
                      
                      
                      
                      
                      
                        Time:
                        
                          
                            Tuesday 10:15 - 11:15
                          
                          
                        
                       
                      
                        Location:
                        
                          
                            
                              
                                Archauz
                              
                              
                            
                          
                          
                        
                       
                      
                        
                          Abstract: Everyone is saying we need a revolution in the way we approach concurrency; 
the availability of cheap multiprocessor systems has brought concurrency, 
which used to be a topic for experts only, into the foreground.  How did we 
get here?  Why are the performance-enhancing techniques that worked for twenty 
years no longer working, and how did this become such a problem that we have 
to change our programming models?  In this talk, we'll dive under the hood and 
look at the hardware trends that have forced us to turn away from increasing 
sequential performance and towards multicore CPUs and chip multi-threading, 
and look at the implications for software design and performance analysis.
 
 
Keywords:Multicore, concurrency, performance.
 
 
Target audience: Advanced engineers who are interested in performance management and tuning, trends in software design, or anyone who is interesting in understanding the magic under the hood.
                         
                      
                    
                      Presentation: "Concurrency Expert Panel"
                      
                      
                      
                      
                      
                      
                      
                      
                        Time:
                        
                          
                            Tuesday 13:30 - 14:30
                          
                          
                        
                       
                      
                        Location:
                        
                          
                            
                              
                                Archauz
                              
                              
                            
                          
                          
                        
                       
                      
                        
                          Abstract: One theme of the panel is concurrent programming models. Specifically; classic locking, transactional memory and actors. And with concurrency we mean parallel systems (e.g. shared-memory multicore, cluster) 
- The goal is performance
 - One trust domain
 - Latencies are small and predicable
 - One failure => kill the program is just about tolerable
 - One of the goals for the discussion would be to get a better understanding of strengths and weaknesses; advice and discussion about when to use which model.
  
Another goal is:
 
- for the audience to get to pick the brains of the experts
 - to get a good discussion going amongst the experts
 - to get concrete advice on choice of programming language (hence model) for certain problems.
 -  advice on solving common problems that appear when using a particular model.
  
                         
                      
                    
                    
  
     
     
   | 
            | 
        
        
          |   |