towards typesafe join points for modular reasoning in
play

Towards Typesafe Join Points for Modular Reasoning in - PowerPoint PPT Presentation

Sep 13, 2022 •374 likes •1.57k views

Towards Typesafe Join Points for Modular Reasoning in Aspect-Oriented Programs Eric Bodden joint work with Milton Inostroza, ric Tanter

  1. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  2. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  3. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  4. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  5. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { seed==<time> System.out.println(“seed was:”+theSeed); theSeed==0 return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  6. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { seed==<time> System.out.println(“seed was:”+theSeed); theSeed==0 return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  7. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { seed==<time> System.out.println(“seed was:”+theSeed); theSeed==0 return monteCarlo(theSeed); }(seed); return result; } jpi int JP(long s); int around JP (long mySeed) { return proceed(0); } 20

  8. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); result==??? return result; } jpi int JP(long s); int around JP (long mySeed) { new Thread() { public void run() { proceed(mySeed); } }.start(); } 20

  9. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); result==??? return result; } jpi int JP(long s); int around JP (long mySeed) { CJPs are new Thread() { public void run() { expressions, proceed(mySeed); } not statements! }.start(); } 20

  10. int monteCarloAlg() { long seed = System.currentTimeMillis(); int result; result = exhibit JP(long theSeed) { System.out.println(“seed was:”+theSeed); return monteCarlo(theSeed); }(seed); result==42 return result; } jpi int JP(long s); int around JP (long mySeed) { CJPs are new Thread() { public void run() { expressions, proceed(mySeed); } not statements! }.start(); return 42; } 20

  11. Closure joinpoints: aspect side JPIs, as before jpi int JP(long s); advice directly int around JP(long seed) { refers to that return proceed(0); } joinpoint type no pointcuts required 21

  12. Closure joinpoints: base-code side reference to jpi int JP(long s); same JPI base code result = exhibit JP(long theSeed) { println(“seed was:”+theSeed); exhibits joinpoint return monteCarlo(theSeed); as call to closure }(seed); 22

  13. Variable-access rules class C { Field f; void foo(Param fp) { Local l; final Local L; exhibit JP(Param cp) { }(..); } } 23

  14. Variable-access rules class C { Field f; void foo(Param fp) { Local l; final Local L; exhibit JP(Param cp) { f = null; }(..); } } May read and write fields 23

  15. Variable-access rules class C { Field f; void foo(Param fp) { Local l; final Local L; exhibit JP(Param cp) { println(cp); }(..); } } May read (and write) closure parameters 23

  16. Variable-access rules class C { Field f; void foo(Param fp) { Local l; final Local L; exhibit JP(Param cp) { println(L); }(..); } } May read final locals 23

  17. Variable-access rules class C { Field f; X void foo(Param fp) { Local l; X final Local L; exhibit JP(Param cp) { println(l); println(fp); }(..); } } May NOT access non-final locals 23

  18. Control-flow rules class C { void foo() { for(int i=0;i<5;i++) { exhibit JP(){ }(); println(i); } } } 24

  19. Control-flow rules class C { void foo() { for(int i=0;i<5;i++) { exhibit JP(){ return; }(); println(i); } } } 24

  20. Control-flow rules class C { void foo() { for(int i=0;i<5;i++) { exhibit JP(){ return; }(); println(i); } } } “upward FUNARG problem” void around JP() { new Thread() { (Weizenbaum 1968, public void run() { Moses 1970) proceed(); } }.start(); } 24

  21. Control-flow rules class C { prints: void foo() { for(int i=0;i<5;i++) { 1 exhibit JP(){ 2 return; 3 }(); 4 println(i); 5 } } } break / continue / return always bind to closure, not to declaring method! 24

  22. Control-flow rules class C { void foo() { for(int i=0;i<5;i++) { exhibit JP(){ break; }(); println(i); } } } break / continue / return always bind to closure, not to declaring method! 24

  23. Control-flow rules class C { void foo() { for(int i=0;i<5;i++) { exhibit JP(){ continue; }(); println(i); } } } break / continue / return always bind to closure, not to declaring method! 24

  24. Syntactic sugar exhibit JP{ exhibit JP(){ ≡ }; }(); 25

  25. CJPs and JPIs Tight integration: A closure joinpoint is just a special joinpoint and is processed like any other joinpoint. 26

  27. Will it blend?

  28. Will it blend? www.willitblend.com

  29. t y Will it blend? p e ?

  30. Checked Exceptions jpi void JPNone(); jpi void JPEx() throws Exception; 30

  31. Checked Exceptions jpi void JPNone(); jpi void JPEx() throws Exception; Will it before JPNone() throws Exception { } type? before JPEx() throws Exception { } 30

  32. Checked Exceptions jpi void JPNone(); jpi void JPEx() throws Exception; Will it before JPNone() throws Exception { } type? before JPEx() throws Exception { } 30

  33. Checked Exceptions jpi void JPNone(); jpi void JPEx() throws Exception; before JPNone() throws Exception { } before JPEx() throws Exception { } void foo() { ... exhibit JPNone() { ... } Will it } type? void bar() { ... exhibit JPEx() { ... } } 30

  34. Checked Exceptions jpi void JPNone(); jpi void JPEx() throws Exception; before JPNone() throws Exception { } before JPEx() throws Exception { } void foo() { ... exhibit JPNone() { ... } Will it } type? void bar() { ... exhibit JPEx() { ... } } 30

  35. Invariant Return Types public aspect TestCase { static void correct() { HashSet s = exhibit JP { ... }; } jpi HashSet JP(); Set around JP() { return new TreeSet(); } } 31

  36. Invariant Return Types public aspect TestCase { static void correct() { HashSet s = exhibit JP { ... }; } jpi HashSet JP(); Set around JP() { return new TreeSet(); } } 31

  37. Invariant Return Types public aspect TestCase { static void correct() { HashSet s = exhibit JP { ... }; } jpi HashSet JP(); Set around JP() { return new TreeSet(); } } 31

  38. Invariant Return Types public aspect TestCase { static void correct() { HashSet s = exhibit JP { ... }; } jpi HashSet JP(); Set around JP() { HashSet around JP() { return new TreeSet(); } } 31

  39. Invariant Return Types public aspect TestCase { static void correct() { HashSet s = exhibit JP { ... }; } jpi HashSet JP(); Set around JP() { HashSet around JP() { return new TreeSet(); } } ... the same applies to argument types. (Alternative: StrongAspectJ, De Fraine et al., AOSD 08) 31

  40. Invariant Pointcuts jpi ¡void ¡JP(Number ¡n); aspect ¡A{ ¡ ¡exhibits ¡void ¡JP(Number ¡n) ¡: ¡call(void ¡*(..)) ¡&& ¡args(n); ¡ ¡public ¡static ¡void ¡main(String[] ¡args){ ¡ ¡ ¡ ¡ ¡ ¡foo(new ¡Integer(2)); ¡ ¡} ¡ ¡void ¡around ¡JP(Number ¡l){ ¡ ¡ ¡ ¡ ¡ ¡proceed(new ¡Float(3)); ¡ ¡} ¡ ¡public ¡static ¡void ¡foo(Integer ¡a){} } 32

  41. Invariant Pointcuts jpi ¡void ¡JP(Number ¡n); aspect ¡A{ ¡ ¡exhibits ¡void ¡JP(Number ¡n) ¡: ¡call(void ¡*(..)) ¡&& ¡args(n); ¡ ¡public ¡static ¡void ¡main(String[] ¡args){ ¡ ¡ ¡ ¡ ¡ ¡foo(new ¡Integer(2)); ¡ ¡} ¡ ¡void ¡around ¡JP(Number ¡l){ AspectJ: match ¡ ¡ ¡ ¡ ¡ ¡proceed(new ¡Float(3)); ¡ ¡} ¡ ¡public ¡static ¡void ¡foo(Integer ¡a){} } 32

  42. Invariant Pointcuts jpi ¡void ¡JP(Number ¡n); aspect ¡A{ ¡ ¡exhibits ¡void ¡JP(Number ¡n) ¡: ¡call(void ¡*(..)) ¡&& ¡args(n); argsinv(n); ¡ ¡public ¡static ¡void ¡main(String[] ¡args){ ¡ ¡ ¡ ¡ ¡ ¡foo(new ¡Integer(2)); ¡ ¡} ¡ ¡void ¡around ¡JP(Number ¡l){ argsinv: no match ¡ ¡ ¡ ¡ ¡ ¡proceed(new ¡Float(3)); ¡ ¡} ¡ ¡public ¡static ¡void ¡foo(Integer ¡a){} } 32

  43. Invariant Pointcuts Same for thisinv and targetinv Warning if exhibits uses this/target/args Not nice but maybe AspectJ should have used different semantics in the first place... 33

  44. More flexible typing through type parameters void printSet(Set s) { ... } Set around LogMe() { Set ret = proceed(); printSet(ret); jpi Set LogMe(); return ret; } exhibits Set LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 34

  45. More flexible typing through type parameters void printSet(Set s) { ... } Set around LogMe() { Set ret = proceed(); printSet(ret); jpi Set LogMe(); return ret; new TreeSet(); } exhibits Set LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 34

  46. More flexible typing through type parameters void printSet(Set s) { ... } Set around LogMe() { Set ret = proceed(); printSet(ret); jpi Set LogMe(); return ret; new TreeSet(); } exhibits Set LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 34

  47. More flexible typing through type parameters void printSet(Set s) { ... } Prevent error by Set around LogMe() { not matching! Set ret = proceed(); printSet(ret); jpi Set LogMe(); return ret; new TreeSet(); } exhibits Set LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 34

  48. More flexible typing through type parameters StrongAspectJ, De Fraine et al., AOSD 08 void printSet(Set s) { ... } <S extends Set> S around LogMe() { S ret = proceed(); printSet(ret); jpi <S extends Set> S LogMe(); return ret; } <S extends Set> exhibits S LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 35

  49. More flexible typing through type parameters StrongAspectJ, De Fraine et al., AOSD 08 void printSet(Set s) { ... } <S extends Set> S around LogMe() { S ret = proceed(); printSet(ret); jpi <S extends Set> S LogMe(); return ret; } <S extends Set> exhibits S LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 35

  50. More flexible typing through type parameters StrongAspectJ, De Fraine et al., AOSD 08 void printSet(Set s) { ... } <S extends Set> S around LogMe() { S ret = proceed(); printSet(ret); jpi <S extends Set> S LogMe(); return ret; new TreeSet(); } <S extends Set> exhibits S LogMe(): call(* foo()); HashSet foo() { .. } HashSet s = foo(); 35

  51. More flexible typing through type parameters StrongAspectJ, De Fraine et al., AOSD 08 void printSet(Set s) { ... } <S extends Set> S around LogMe() { S ret = proceed(); printSet(ret); return ret; } 35

  52. Supporting logging-like concerns through global pointcuts <R> R around LogMe() { long timeBef = time(); R ret = proceed(); print(timeBef-time()); return ret; } class A { <R> exhibits R LogMe(): ... } class B { <R> exhibits R LogMe(): ... } class C { <R> exhibits R LogMe(): ... } ... 36

  53. Supporting logging-like concerns through global pointcuts jpi <R> R LogMe(): call(* *(..)); Introduces default: class A { } ≡ class A { <R> exhibits R LogMe(): call(* *(..)); } 37

  54. Do allow for refinements... Seal a class: class A { <R> exhibits R LogMe(); } Add joinpoints: class A { <R> exhibits R LogMe(): global() || set(* *); } 38

  55. Do allow for refinements... Seal a class: class A { <R> exhibits R LogMe(); } Refine joinpoints: class A { <R> exhibits R LogMe(): global() && call(* foo()); } 39

  56. Result of typing rules Invocation of a closure can never fail at runtime! Strong typing! 40

  57. Result of typing rules Invocation of a closure can never fail at runtime! 40

  58. Join Point Polymorphism jpi ¡CheckingOut jpi ¡Buying jpi ¡Renting jpi ¡void ¡CheckingOut(float ¡price, ¡Customer ¡c) 41

  59. Join Point Polymorphism jpi ¡CheckingOut jpi ¡Buying jpi ¡Renting jpi ¡void ¡CheckingOut(float ¡price, ¡Customer ¡c) jpi ¡void ¡Buying(Item ¡i, ¡float ¡price, ¡Customer ¡cust) extends ¡CheckingOut(price,cust); 41

  60. Join Point Polymorphism jpi ¡CheckingOut jpi ¡Buying jpi ¡Renting jpi ¡void ¡CheckingOut(float ¡price, ¡Customer ¡c) jpi ¡void ¡Buying(Item ¡i, ¡float ¡price, ¡Customer ¡cust) extends ¡CheckingOut(price,cust); “width subtyping” 41

  61. Join Point Polymorphism jpi ¡CheckingOut jpi ¡Buying jpi ¡Renting jpi ¡void ¡CheckingOut(float ¡price, ¡Customer ¡c) jpi ¡void ¡Buying(Item ¡i, ¡float ¡price, ¡Customer ¡cust) extends ¡CheckingOut(price,cust); jpi ¡void ¡Renting(float ¡price, ¡int ¡amt, ¡Customer ¡c) extends ¡CheckingOut(price,c); 41

  62. Advice-dispatch semantics Aspect Discount around CheckingOut Buying around Buying Join Point The most specific jpi ¡CheckingOut advice gets executed. jpi ¡Buying jpi ¡Renting 42

Recommend

Modular Reasoning for Actor Specification Diagrams Rigorous reasoning for open distributed

Modular Reasoning for Actor Specification Diagrams Rigorous reasoning for open distributed

Reasoning About Open Systems Project Collaboration with Agha, Mason, Smith, Talcott Modular Reasoning for Actor Specification Diagrams Rigorous reasoning for open distributed systems Scott F . Smith General multi-language framework

428 views • 10 slides
Verification of Parameterized Concurrent Programs By Modular Reasoning about Data and Control

Verification of Parameterized Concurrent Programs By Modular Reasoning about Data and Control

Verification of Parameterized Concurrent Programs By Modular Reasoning about Data and Control Zachary Kincaid Azadeh Farzan University of Toronto January 18, 2013 Z. Kincaid (U. Toronto) Modular Reasoning about Data and Control January 18,

751 views • 54 slides
enabled by Circular Economy Service Platform join CEP Be part of the future transformation join

enabled by Circular Economy Service Platform join CEP Be part of the future transformation join

New business from industrial waste &amp; side streams - enabled by Circular Economy Service Platform join CEP Be part of the future transformation join CEP Collaborate with your partners join CEP Create a new value cluster Modular and

223 views • 18 slides
Today. Summary: polynomials. Farewell (for now) to modular arithmetic... Set of d + 1 points

Today. Summary: polynomials. Farewell (for now) to modular arithmetic... Set of d + 1 points

Today. Summary: polynomials. Farewell (for now) to modular arithmetic... Set of d + 1 points determines degree d polynomial. Modular arithmetic modulo a prime. Encode secret using degree k 1 polynomial: Add, subtract, commutative,

431 views • 7 slides
Aspects and Modular Reasoning in Nonmonotonic Logic Klaus Ostermann Darmstadt University of

Aspects and Modular Reasoning in Nonmonotonic Logic Klaus Ostermann Darmstadt University of

Aspects and Modular Reasoning in Nonmonotonic Logic Klaus Ostermann Darmstadt University of Technology FOAL07 Background Many people have noted that programs should look like our thought

374 views • 23 slides
Independence of points on elliptic curves coming from modular curves Gregorio Baldi XXI

Independence of points on elliptic curves coming from modular curves Gregorio Baldi XXI

Independence of points on elliptic curves coming from modular curves Gregorio Baldi XXI Congresso dellunione Matematica Italiana, Sezione di Teoria dei Numeri Pavia, 06/09/2019 G. Baldi Independence of points 06/09/2019 1 / 17 Main

954 views • 59 slides
The rational group structure of modular Jacobians with applications to torsion points on elliptic

The rational group structure of modular Jacobians with applications to torsion points on elliptic

The rational group structure of modular Jacobians with applications to torsion points on elliptic curves over number fields Maarten Derickx 1 Algant (Leiden, Bordeaux and Milano) LMFDB Workshop 05-06-2014 Talk will only start after you opened:

861 views • 22 slides
modular forms of weight one, and Stark-Heegner points. Henri Darmon San Diego, September 20-22,

modular forms of weight one, and Stark-Heegner points. Henri Darmon San Diego, September 20-22,

Starks Conjecture and related topics p -adic iterated integrals , modular forms of weight one, and Stark-Heegner points. Henri Darmon San Diego, September 20-22, 2013 (Joint with Alan Lauder and Victor Rotger ) Starks conjectures

568 views • 41 slides
Sporadic points on modular curves David Zureick-Brown (Emory University) Anastassia Etropolski

Sporadic points on modular curves David Zureick-Brown (Emory University) Anastassia Etropolski

Sporadic points on modular curves David Zureick-Brown (Emory University) Anastassia Etropolski (Foursquare) Maarten Derickx (MIT) Jackson Morrow (Centre de Recherches Mathematiques, Berkeley) Mark van Hoeij (Florida State University) Slides

506 views • 38 slides
Rational Points on Modular Elliptic Curves I. Elliptic Curves Hedrick Lecture Series MAA

Rational Points on Modular Elliptic Curves I. Elliptic Curves Hedrick Lecture Series MAA

Rational Points on Modular Elliptic Curves I. Elliptic Curves Hedrick Lecture Series MAA MathFest Boulder, Colorado August 2003 http://www.math.mcgill.ca/darmon /slides/slides.html Elliptic Curves Definition : An elliptic curve over the

494 views • 26 slides
Rational points on curves over finite fields and Drinfeld modular varieties Alp Bassa Sabanc

Rational points on curves over finite fields and Drinfeld modular varieties Alp Bassa Sabanc

Rational points on curves over finite fields and Drinfeld modular varieties Alp Bassa Sabanc University Curves over Finite Fields Let C be smooth, projective, absolutely irreducible curve over F q . (alternatively F / F q an algebraic function

563 views • 34 slides
Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with

Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with

Thread-Modular Reasoning for Lock-Free Data Structures Roland Meyer based on joint work with Luk Holk, Tom Vojnar, and Sebastian Wol ff . Lock-Free Data Structures Key Take Aways: e ffi cient but complex correctness =

641 views • 53 slides
Continuation Join Points Yusuke Endoh, Hidehiko Masuhara, Akinori Yonezawa (University of Tokyo)

Continuation Join Points Yusuke Endoh, Hidehiko Masuhara, Akinori Yonezawa (University of Tokyo)

Continuation Join Points Yusuke Endoh, Hidehiko Masuhara, Akinori Yonezawa (University of Tokyo) 1 Background: Aspects are reusable in AspectJ (1) Example: A generic logging aspect can log user inputs in a CUI program by defining a

364 views • 33 slides
GADTs Practice Curtis Millar CSE, UNSW (and Data61) 22 July 2020 1 Exercise 5 GADTs TypeSafe

GADTs Practice Curtis Millar CSE, UNSW (and Data61) 22 July 2020 1 Exercise 5 GADTs TypeSafe

Exercise 5 GADTs TypeSafe printf More on Vectors Administrivia Software System Design and Implementation GADTs Practice Curtis Millar CSE, UNSW (and Data61) 22 July 2020 1 Exercise 5 GADTs TypeSafe printf More on Vectors Administrivia

762 views • 40 slides
CHAPTER-4 1 LOGIC AND REASONING ! Knowledge and ! Reasoning in Knowledge- Reasoning Based

CHAPTER-4 1 LOGIC AND REASONING ! Knowledge and ! Reasoning in Knowledge- Reasoning Based

CHAPTER-4 1 LOGIC AND REASONING ! Knowledge and ! Reasoning in Knowledge- Reasoning Based Systems ! syntax and semantics ! shallow and deep reasoning ! validity and satisfiability ! forward and backward ! logic languages chaining ! alternative

616 views • 23 slides
Without Resilience Nothing Else Matters Jonas Bonr CTO TypEsafe @jboner Without Resilience

Without Resilience Nothing Else Matters Jonas Bonr CTO TypEsafe @jboner Without Resilience

Without Resilience Nothing Else Matters Jonas Bonr CTO TypEsafe @jboner Without Resilience Nothing Else Matters Jonas Bonr CTO TypEsafe @jboner But it aint how hard youre hit; its about how hard you can get hit, and keep

1.5k views • 132 slides
Scala - The Simple Parts Martin Odersky Typesafe and EPFL 10 Years of Scala Grown Up?

Scala - The Simple Parts Martin Odersky Typesafe and EPFL 10 Years of Scala Grown Up?

Scala - The Simple Parts Martin Odersky Typesafe and EPFL 10 Years of Scala Grown Up? Scalas user community is pretty large for its age group. ~ 100000 developers ~ 200000 subscribers to Coursera online courses. #13 in RedMonk

655 views • 52 slides
When to Optimize Enumerating all possible plans Selection Pushdown Join Conversion Join

When to Optimize Enumerating all possible plans Selection Pushdown Join Conversion Join

When to Optimize Enumerating all possible plans Selection Pushdown Join Conversion Join Reordering Pick a Join Algo Which Plan is the Best? Always push down selections Always convert joins Which join order??? Which join algo? What makes a

363 views • 3 slides
Probabilistic Reasoning; Probabilistic Reasoning; Network-based reasoning Network-based

Probabilistic Reasoning; Probabilistic Reasoning; Network-based reasoning Network-based

Probabilistic Reasoning; Probabilistic Reasoning; Network-based reasoning Network-based reasoning COMPSCI 276, Fall 2014 Set 1: Introduction and Background Rina Dechter (Reading: Pearl chapter 1-2, Darwiche chapters 1,3) 1 Why/What/How

700 views • 45 slides
The Trouble with Types Martin Odersky EPFL and Typesafe

The Trouble with Types Martin Odersky EPFL and Typesafe

The Trouble with Types Martin Odersky EPFL and Typesafe Types Everyone has an opinion on them Industry: Used to be the norm (C/C++,

710 views • 48 slides
Evidential and Causal Reasoning Much reasoning in AI can be seen as evidential reasoning ,

Evidential and Causal Reasoning Much reasoning in AI can be seen as evidential reasoning ,

Evidential and Causal Reasoning Much reasoning in AI can be seen as evidential reasoning , (observations to a theory) followed by causal reasoning (theory to predictions). Diagnosis Given symptoms, evidential reasoning leads to hypotheses about

243 views • 8 slides
1 TEMPORARY MODULAR HOUSING Meeting Purpose Learn how Temporary Modular Housing will allow

1 TEMPORARY MODULAR HOUSING Meeting Purpose Learn how Temporary Modular Housing will allow

TEMPORARY MODULAR HOUSING Temporary Modular Housing Community Information Session 7430 7460 Heather Street ( formerly 650 West 57 th Avenue) ) 1 TEMPORARY MODULAR HOUSING Meeting Purpose Learn how Temporary Modular Housing will allow

701 views • 32 slides
Is Join Point a Point? a pointcut and advice mechanism for making aspects more reusable Hidehiko

Is Join Point a Point? a pointcut and advice mechanism for making aspects more reusable Hidehiko

Is Join Point a Point? a pointcut and advice mechanism for making aspects more reusable Hidehiko Masuhara University of Tokyo joint work with Yusuke Endoh and Aki Yonezawa 1 A secret of AspectJ AspectJ is based on join points A sceret

342 views • 23 slides
Above the Clouds: Introducing Akka Jonas Bonr CTO Typesafe Twitter: @jboner torsdag 13

Above the Clouds: Introducing Akka Jonas Bonr CTO Typesafe Twitter: @jboner torsdag 13

Above the Clouds: Introducing Akka Jonas Bonr CTO Typesafe Twitter: @jboner torsdag 13 oktober 11 The problem It is way too hard to build: 1. correct highly concurrent systems 2. truly scalable systems 3. fault-tolerant systems that

1.2k views • 93 slides

More recommend