.net code: some ideas to improve yours

565 views

Published on

ThoughtWorks Café Ágil BH segunda edição

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

  • Be the first to like this

No Downloads
Views
Total views
565
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
4
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

.net code: some ideas to improve yours

  1. 1. .net  code  some  ideas  to  improve  yours   Carlos  Lopes   @carlosaml   ThoughtWorks  
  2. 2. code  
  3. 3. your  code  MATTERS  
  4. 4. so  how  can  you  write  be@er  code?  
  5. 5. and  so  on  
  6. 6. .net  
  7. 7. C#  
  8. 8. stuff  like  that  
  9. 9. ok  
  10. 10.                IEnumerable<int>  FilterAndSort(IEnumerable<int>  numbers)                  {                          var  evens  =  new  List<int>();                            foreach  (var  i  in  numbers)                          {                                  if  (i  %  2  ==  0)                                  {                                          evens.Add(i);                                  }                          }                            evens.Sort();                            return  evens;                  }  
  11. 11. IEnumerable<int>  FilterAndSortRevisited(IEnumerable<int>  numbers)  {        var  evens  =  numbers.Where(i  =>  i  %  2  ==  0).ToList();          evens.Sort();          return  evens;  }  
  12. 12. IEnumerable<int>  FilterAndSortStrikingBack(IEnumerable<int>  numbers)  {          return  numbers                    .Where(i  =>  i  %  2  ==  0)                    .OrderBy(i  =>  i);  }  
  13. 13. IEnumerable<int>  FilterAndSortEvenBe@er(IEnumerable<int>  numbers)  {          return  from  n  in  numbers                      where  n  %  2  ==  0                      orderby  n                      select  n;  }  
  14. 14. IEnumerable<int>  FilterAndSortYetAgain(IEnumerable<int>  numbers)  {              return  from  n  in  numbers                          where  n.IsEven()                          orderby  n                          select  n;  }  
  15. 15. wait  
  16. 16. IEnumerable<int>  FilterAndSortYetAgain(IEnumerable<int>  numbers)  {              return  from  n  in  numbers                          where  n.IsEven()                          orderby  n                          select  n;  }  
  17. 17.  public  staWc  class  MyExtensions    {                  public  staWc  bool  IsEven(this  int  number)                  {                          return  number  %  2  ==  0;                  }    }  
  18. 18. we’ll  come  back  to  this  
  19. 19.                IEnumerable<int>  FilterAndSort(IEnumerable<int>  numbers)                  {                          var  evens  =  new  List<int>();                            foreach  (var  i  in  numbers)                          {                                  if  (i  %  2  ==  0)                                  {                                          evens.Add(i);                                  }                          }                            evens.Sort();                            return  evens;                  }  
  20. 20. IEnumerable<int>  FilterAndSortYetAgain(IEnumerable<int>  numbers)  {              return  from  n  in  numbers                          where  n.IsEven()                          orderby  n                          select  n;  }  
  21. 21. so  what?  
  22. 22. “Any  fool  can  write  code  that  a   computer  can  understand.  Good  programmers  write  code  that   humans  can  understand.”   Mar;n  Fowler  
  23. 23. Robert  C.  Mar;n  
  24. 24. fast,  slow,  slower  rhythm  
  25. 25. Kerievsky’s  5.0  syndrome  
  26. 26. release  1.0  is  quickly  delivered  
  27. 27. release  2.0  is  delivered  
  28. 28. but  the  junky  code  slows  you  down  
  29. 29. then  you  go  slower  and  slower  
  30. 30. mysterious  bugs  
  31. 31. demoWvaWon  
  32. 32. etc  
  33. 33. and  around  release  4.0  …  
  34. 34. complete  rewrite!  
  35. 35. 5.0  !!!  
  36. 36. -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  
  37. 37. less  code  
  38. 38. less  bugs  
  39. 39. “If  you  love  wri;ng  code  -­‐-­‐  really,  truly   love  to  write  code  -­‐-­‐  youll  love  it   enough  to  write  as  liEle  of  it  as   possible.”   Jeff  Atwood  
  40. 40. “Code  is  bad.  It  rots.  It  requires  periodic  maintenance.  It  has  bugs  that  need  to  be  found.  New  features  mean   old  code  has  to  be  adapted.”   Rich  Skrenta  
  41. 41. coming  back  
  42. 42. funcWonal  programming  
  43. 43. “Typically  the  main  func;on  is  defined   in  terms  of  other  func;ons,  which  in   turn  are  defined  in  terms  of  s;ll  more  func;ons,  un;l  at  the  boEom  level  the   func;ons  are  language  primi;ves.”   John  Hughes  –  “Why  Func;onal  Programming  MaEers”  
  44. 44. F#,  ok  
  45. 45. but  
  46. 46. C#  ?!?!  
  47. 47. C#  is  an  imperaWve  language,  dude  
  48. 48. agreed  
  49. 49. but  
  50. 50. how  about  mixing  paradigms?  
  51. 51. again,  …  
  52. 52. less  code  
  53. 53. less  bugs  
  54. 54. -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  
  55. 55. expressiveness  
  56. 56. say  what  
  57. 57. IEnumerable<int>  FilterAndSortYetAgain(IEnumerable<int>  numbers)  {              return  from  n  in  numbers                          where  n.IsEven()                          orderby  n                          select  n;  }  
  58. 58. not  how  
  59. 59.                IEnumerable<int>  FilterAndSort(IEnumerable<int>  numbers)                  {                          var  evens  =  new  List<int>();                            foreach  (var  i  in  numbers)                          {                                  if  (i  %  2  ==  0)                                  {                                          evens.Add(i);                                  }                          }                            evens.Sort();                            return  evens;                  }  
  60. 60. ok  
  61. 61. what  else?  
  62. 62. funcWons  are  kind  of  a  big  deal  
  63. 63. principle  of  least  surprise  
  64. 64. immutability  
  65. 65. no  side-­‐effects  
  66. 66. lazy  evaluaWon  
  67. 67. higher-­‐order  funcWons  
  68. 68. etc  
  69. 69. but  how?  
  70. 70. extension  methods  
  71. 71. IEnumerable<int>  FilterAndSortYetAgain(IEnumerable<int>  numbers)  {              return  from  n  in  numbers                          where  n.IsEven()                          orderby  n                          select  n;  }  
  72. 72.  public  staWc  class  MyExtensions    {                  public  staWc  bool  IsEven(this  int  number)                  {                          return  number  %  2  ==  0;                  }    }  
  73. 73.  public  staWc  class  MyExtensions    {                  public  staWc  bool  IsEven(this  int  number)                  {                          return  number  %  2  ==  0;                  }    }  
  74. 74. LINQ  
  75. 75. IEnumerable<int>  FilterAndSortStrikingBack(IEnumerable<int>  numbers)  {          return  numbers                    .Where(i  =>  i  %  2  ==  0)                    .OrderBy(i  =>  i);  }  
  76. 76. a  nice  way  to  query  stuff  
  77. 77. series  of  extension  methods  
  78. 78. Select()   Skip()   Take()  OrderBy()  GroupBy()   Where()     …  
  79. 79. +  
  80. 80. syntacWc  sugar  
  81. 81. IEnumerable<int>  FilterAndSortStrikingBack(IEnumerable<int>  numbers)  {          return  numbers                    .Where(i  =>  i  %  2  ==  0)                    .OrderBy(i  =>  i);  }  
  82. 82. IEnumerable<int>  FilterAndSortEvenBe@er(IEnumerable<int>  numbers)  {          return  from  n  in  numbers                      where  n  %  2  ==  0                      orderby  n                      select  n;  }  
  83. 83. laziness  
  84. 84. iterators  
  85. 85.                IEnumerable<int>  Fibonacci()                  {                          yield  return  0;                          yield  return  1;                            var  previous  =  0;                          var  current  =  1;                          while  (true)                          {                                  var  next  =  previous  +  current;                                  yield  return  next;                                  previous  =  current;                                  current  =  next;                          }                  }  
  86. 86.                IEnumerable<int>  Fibonacci()                  {                          yield  return  0;                          yield  return  1;                            var  previous  =  0;                          var  current  =  1;                          while  (true)                          {                                  var  next  =  previous  +  current;                                  yield  return  next;                                  previous  =  current;                                  current  =  next;                          }                  }  
  87. 87.                IEnumerable<int>  Fibonacci()                  {                          yield  return  0;                          yield  return  1;                            var  previous  =  0;                          var  current  =  1;                          while  (true)                          {                                  var  next  =  previous  +  current;                                  yield  return  next;                                  previous  =  current;                                  current  =  next;                          }                  }  
  88. 88. watch  out:    performance   side  effects   …  
  89. 89. lambdas  
  90. 90. IEnumerable<int>  FilterAndSortStrikingBack(IEnumerable<int>  numbers)  {          return  numbers                    .Where(i  =>  i  %  2  ==  0)                    .OrderBy(i  =>  i);  }  
  91. 91. syntacWc  sugar  
  92. 92. anonymous  methods  
  93. 93.                IEnumerable<int>  FilterAndSortStrikingBackAgain                                    (IEnumerable<int>  numbers)                  {                          return  numbers.Where(delegate(int  number)  {  return  number%2  ==  0;  });                  }  
  94. 94. delegates  
  95. 95. funcWon  pointers  
  96. 96. pass  funcWons  around  
  97. 97. -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  -­‐-­‐-­‐-­‐-­‐  
  98. 98. one  more  thing  
  99. 99. don’t  forget  OO  
  100. 100. you  might  be  tempted  
  101. 101. order.Items.Select(item  =>  item.Price).Max();  
  102. 102. (from  item  in  order.Items  select  item.Price).Max();  
  103. 103. duplicaWon  
  104. 104. encapsulaWon  
  105. 105. all  right  
  106. 106. that’s  about  it  for  today  I  guess  
  107. 107. quesWons?  
  108. 108. thank  you!  

×