Speaking of that, good posts of tree-traversal: Catamorphisms in F# (Part 1, 2, 3, 4, 5, 6, 7)

posted by Thorium

I'll try to explain here.

posted by Thorium

Thanks! Downloading...

posted by Thorium

posted by Thorium

IO<Result> res1 = GetWebserviceRequest();// (or/and FromEventPattern);
var res2 = res1.MuchLinqHere();
var res3 = res2.ObserveOnDispatcher();
var res4 = res3.LessLinqHere();
var d = res4.Subscribe { ... };

The great thing about Rx is that it is much more efficient than normal events: "MuchLinqHere()" don't cause load to the UI thread. I'm happy with that.

"LessLinqHere()" will cause load to UI thread as it is executed there, right? So... In this application there is a lot of code. I try to call ObserveOnDispatcher as late as possible.

It has to be called before the code tries to make a side effect in Linq: e.g. access Application.Current... or UI.

Now, are you saying in the video that in Rx2.0:

1. The ObserveOnDispatcher() will happen automatically before "MuchLinqHere()"? Will I lose performance? 
2. Or will it be called just before Subscribe? (Then will it still throw if there are side effects in Linq?)

posted by Thorium

posted by Thorium

It turns out you can't: http://stackoverflow.com/questions/1732348/regex-match-open-tags-except-xhtml-self-contained-tags/1732454#1732454 

How about will Roslyn expose some of C# compiler internal TRs to public?

posted by Thorium

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.

posted by Thorium

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

posted by Thorium

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.

posted by Thorium

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...?

posted by Thorium

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.

posted by Thorium

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.

posted by Thorium

But how about using ReSharper with C#?

posted by Thorium

posted by Thorium

How about transactions with type providers?

posted by Thorium

• 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).

posted by Thorium

posted by Thorium

Both can have multiple sub-algorithms/functions.

The problem of the sameness is just that we can't define the precise captured begin and end states of the algorithms,

If the universe is the "main state"... The evolution is just an algorithm, state transforming to another through various sub-states.

We can use monadic bind to combine functions, so that is also true to algorithms, right? (like in the PDC presentation of F# 3.0, which shows the similarity between compilers and search engines.)

posted by Thorium

Sounds like this key-value database algorithm to go back in time to resolve transactions is NP-complete, so I wonder if it really works in a large bank.

---

That A => IOU(IOU(A)) will not guarantee IOU(IOU(A)) => A, can be seen with the type system: The input and output types of the function "=>" will be different.

Speaking of types... Lecture's description of programming language hits some pain points of C#:

interface ProgrammingLanguage 
{  
 IEnumerable<Command> Keywords<Command>() where Command : Func<Command, Command>;
}

where the actual Command should be an option type of Func, Action or a Type, right?

posted by Thorium

• I can't really debug Unit tests when using Silverlight Reactive Extensions (Silverlight Rx library with .NET core test cases).
• One case when calling .Subscribe() I get an exception before onNext evaluation: "Collection was modified; enumeration operation may not execute." But I don't know which collection! How can this be possible, I thought that Observables are like "history of events", and you can't modify history... Because this is before the first onNext, I don't find a way to debug.

And questions:

• Ain't there pdb-files to debug the Rx core...?
• Should I dispose manually? When?
• How will Rx work with Silverlight two-way data binding?

posted by Thorium

posted by Thorium

posted by Thorium