Tuomas Hietanen

• Keynote - Martin Odersky: Reflection and Compilers

  Apr 25, 2012 at 2:31 PM

  Scala may be the best choice for JVM environment. It gives developers some functional concepts but is quite simple language still (for a Java developer). This was a great presentation. Also challenging audience.

  However, I didn't like the "Cake pattern". It reminds me of the C# partial classes: Try to be object-oriented (classes) but still break two basic design principles of OO:

  1. Single responsibility principle: Composition classes often have many responsibilities.

  2. Open Close Principle: Software entities like classes, modules and functions should be open for extension but closed for modifications. This means that the internal state and design of the entity should not be visible to outside.

• Going Deeper with Project Roslyn: Exposing the C# and VB compiler’s code analysis

  Apr 23, 2012 at 12:16 PM

  Too bad that Visual Basic and C# are overlapping languages. So there is double work with no real gain.

  Hopefully interfaces and API:s are open and well documented, so future (community projects?) could add support for languages like Javascript and F#.

• Lang.NEXT 2012 Expert Panel: Web and Cloud Programming (and more)

  Apr 21, 2012 at 1:46 PM

  Yes interesting...

  Apr 10, 2012 at 5:26 PM

  It's very strange that this panel didn't mentioned F# at all.
  

  I agree. In F# you can write same kind of code inside and outside a monad (="computational expression") where e.g. in C# you have to move from old imperative ("normal") code to LINQ-syntax.

   

• Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask)

  Apr 10, 2012 at 8:53 AM

  Hi, nice video!

  This important subject has got a lot of attention lately. I'll expect some interesting conversation here (or maybe part 2)...

  With F# I have used the type mailboxprocessor, often called agent model.

  I googled the differences between actors and agents, and the result was not completely in sync with this video. So what are the differences of these terms, or are they equivalent:

  • Actors
  • Agents
  • Message passing
  • Mailboxprocessors

  As far as I understand: the main difference of agents and actors (which both are implementations of message passing) is between the control: actors control themselves while agents are controlled from somewhere outside.

  Hewitt said it would be a miss-understanding to see actors as event loop (OO-programmer may refer event loop as CQRS Event Sourcing), because actors know their internal state. Is that the only difference? From the outside view they are pretty close though, aren't they? For example: Reactive Extensions has this class ReplaySubject. I use it and it works. But do I know if it uses actor model or event loop inside...?

   

• Tao Liu: F# Design Patterns

  Mar 03, 2012 at 2:13 AM

  Hello,

  First of all, thanks, F#-team is making a great job. And these kind of videos are good to get a great language some attention.

  But I have some small critics to these samples... Samples teach programmers so they shouldn't teach bad things. They should teach best practices, not tricks or hacks.

  Tricks are good to know also... But maybe these samples could be divided to two sections: 1. howto, 2. tricks.

  1. Why to teach programmers to use mutable state so much? There is a very good reason why mutable state is not default in F#.

  2. Why using inline keyword in samples? Inline is usually just for interactive. Msdn says this: "you should avoid using inline functions for optimization unless you have tried all other optimization techniques". So why do we need this in basic samples? http://msdn.microsoft.com/en-us/library/dd548047.aspx

  I'm F#-programmer, and one of those who thinks that Design Patterns are common "best practice" ways to manage object-oriented problems that doesn't exist in functional language.

   

• C9 Lectures: Graham Hutton - How To Be More Productive

  Jan 29, 2012 at 4:43 AM

  I will give five stars to every talk about y-combinator.

  The explanation of subject of how-to-make-a-next-item vs. what-is-the-formula is not trivial for basic mathematics school-teachers, so it may need more research.

  But I wouldn't say that "generator function" (that makes next items) are plain easier. They may seem easier to construct (as their construction process is usually imperative), but... It doesn't mean that you will find the right pattern-match by accident.

   

• Brian Beckman: Hidden Markov Models, Viterbi Algorithm, LINQ, Rx and Higgs Boson

  Dec 28, 2011 at 4:29 PM

  I also would prefer F#.

  But how about using ReSharper with C#?

   

• F# 3.0: data, services, Web, cloud, at your fingertips

  Sep 21, 2011 at 5:32 AM

  Where do I get this Samples.DataStore.Freebase.dll ?

• F# 3.0: data, services, Web, cloud, at your fingertips

  Sep 17, 2011 at 5:39 PM

  Nice. So will F# 4.0 focus on presentation?

  How about transactions with type providers?

   

• Anders Hejlsberg: Questions and Answers

  May 19, 2011 at 10:12 AM

   

  • Is this "not support for non-nullable-reference-type" a c# or clr feature?

   

  • Currently in enterprise software the case is often that we would need some common functionality
    without knowing the exact type. When we don't have higher order types this usually
    leads to reflection (and runtime-errors).

See more comments…