I've been cooking a side-project that aims to ensure that the programming screencasts I find useful would get a wider reach, as well as keep me up to date.

It's called Learnivore, comes with a RSS feed and a full-text search (tags are planned).

While it's mostly Ruby, RubyOnRails and iPhone related so far, I intend to broaden what's in there with more .Net content (including IronRuby, IronPython, F# and more).

So first I hope some of you will find this useful - and if you have interesting screencasts sources related to the .Net world, I'm all hears :)

If you're into this, you should definitely have a look at the Sympl language sample (see Sympl.doc).

This document was accompanied by this message, posted by Curt Hagenlocher on behalf of Bill Chiles to the IronRuby core list:

There's a new DLR sample to which I wanted to draw folks' attentions.
There is a small language implementation sample, implemented in both
IronPython and C#, with an accompanying walkthrough document. The code
is now on the DLR Codeplex site under ...\Languages\Sympl, and the
document is on the "Documents and Specs" page which you can get to from
the list of links on the home page. Under the Sympl directory is also
an examples directory with some code written in Sympl, which all runs
when you execute Main in program.cs. The code and document will be in
zip files we will produce to go along with the VS Beta1 release coming
soon.

Sympl demonstrates how to implement a very simple language using the
Dynamic Language Runtime (DLR) as it ships in .NET 4.0. The goal is to
make you aware of how to get started building a language on the DLR.
Sympl does not show production quality rich .NET interoperability and
binding logic. It does walk you through the following:

* Using DLR Expression Trees (which include LINQ Expression Trees v1)
for code generation
* Using DLR dynamic dispatch caching
* Building runtime binders
* Building dynamic objects and dynamic meta-objects
* Supporting dynamic language/object interoperability
* Very simple hosting with application supplied global objects
* Basic arithmetic and comparison operators with fast DLR dispatch
caching
* Control flow
* Name binding within Sympl
* Method and top-level function invocation with fast DLR dispatch
caching
* Very simple .NET interoperability for runtime method and operation
binding
* Using the DLR's built-in COM binding
* Closures
* Assignment with various left-hand-side expressions
Sympl does not yet demonstrate using any Codeplex-only DLR code such as
the DefaultBinder, the faster and nicer .NET reflection trackers
(Sympl's is painfully slow and simple), or the common DLR hosting (yet).

A few caveats on the documentation. First, the walk through document
still needs some polishing, but I wanted to get it out to people. Feel
free to send me comments or ask questions. Second, the document refers
to a couple of other documents on our Codeplex site, but we haven't
updated some of them since DEC 08. Those will be updated in the next
couple of weeks. I think the sympl.doc walkthrough is very readable on
its own and has all the relevant code snippets included in it as well.
Lastly, while the example is overall reasonably simple, it does
demonstrate all the basic concepts of building a language on the DLR
with explanations, and therefore, is quite long. However, the document
unfolds in the same way the Sympl language implementation evolved, so it
progresses well for incrementally increasing your awareness of how to
build a language on the DLR.

Hope you enjoy and find this code and doc helpful!

Cheers,
Bill

Have a pleasant and instructive reading (and thanks to Curt and Bill for sharing this).

In .Net, the "BackgroundWorker":http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx provides a nice way to handle out-of-UI thread work while being able to report some progress on the UI side.

Sometimes though, we felt that we wanted something more flexible for our needs, and came up with that:

The reverse is also possible:

You'll notice that we don't pass arguments nor return value unlike other kind of sugars for that (see resources below).

That's because we use lambda's all over the place for that, so what would be parameters and return values can be accessed in the lambda's parent scope directly.

That's what works for us. Now to you: what kind of sugar do you use when dealing with threads in Windows Forms ?

h3. Resources

A few links that you may find useful if you target this kind of subject:

* "old yet very detailed informations on Invoke/BeginInvoke stuff":http://weblogs.asp.net/justin_rogers/pages/126345.aspx
* the "BackgroundWorker":http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx provides convenient sugar to handle cancellable worker thread, with ability to report progress
* "Safe ControlInvoke with Lambda's":http://dotnet.org.za/virtualstaticvoid/archive/2009/01/24/safe-controlinvoke-with-lambda-s.aspx covers a larger number of cases than what's presented here
* "Delegate Marshaler":http://thevalerios.net/matt/2008/07/controlinvokerequired-delegatemarshaler-and-anonymous-methods/ - another way of handling these
* "Safe, Even Simpler Multithreading in Windows Forms 2.0":http://www.mikedub.net/mikeDubSamples/SafeReallySimpleMultithreadingInWindowsForms20/SafeReallySimpleMultithreadingInWindowsForms20.htm - pretty good introduction to UI threading
* "Magic":http://gist.github.com/thbar/magic/tree/master - an IronRuby gem focusing on making it easier to create WPF, Silverlight and Windows Forms stuff from IronRuby (more on that later)

Il s'agit d'une "rencontre informelle et (d') échanges sur Scrum, l'Agilité et bien sur la vie du SUG".

J'ai découvert l'existence de ce "SUG" après être devenu Certified Scrum Product Owner (merci Mike Cohn, formateur absolument fantastique), en explorant les ressources disponibles sur le site de la Scrum Alliance.

Au passage, Meetup.com est un outil bien réalisé et pratique pour organiser ce genre de réunions.

Peut être à la semaine prochaine si vous y êtes!

I currently know about two great publishers (please comment if you know others).

"PeepCode":http://peepcode.com/ is a place with a lot of Rails and RSpec related-content, but you will also find things that could be relevant to .Net, depending on what you're currently experimenting:
* "Ajax with Prototype.js":https://peepcode.com/products/ajax-with-prototypejs
* "Javascript with Prototype.js":https://peepcode.com/products/javascript-with-prototypejs
* "Benchmark with httperf":https://peepcode.com/products/benchmarking-with-httperf
* "Git":https://peepcode.com/products/git - if you're into decentralized version control
* "CouchDB":https://peepcode.com/products/couchdb-with-rails - CouchDB is a nice document oriented database; great to handle semi-structured data for instance.

These screencasts are priced at 9$ each (at time of writing).

"The Pragmatic Programmers":http://www.pragprog.com/screencasts also propose a series of screencasts, including episodes on "Erlang in practice":http://www.pragprog.com/screencasts/v-kserl/erlang-in-practice or "Writing your first iPhone application":http://www.pragprog.com/screencasts/v-bdiphone/writing-your-first-iphone-application.

h3. Yourself as an internal publisher

Finally, some "friends of mine":http://clt-services.com/ have "started using screencasts inside their company to share knowledge":http://evolvingworker.com/2008/10/13/using-screencasts-to-share-knowledge-inside-a-company. I believe it is a very interesting practice.

Do you know other interesting screencasts publishers ? Please comment!

That's .Net code, unit-tested using IronRuby. The testing syntax mimics the RSpec testing framework. A couple of years ago I wished this kind of thing could become possible.

Sweet - and something I would not be surprised to see widely used in another couple of years. See you then!

Here are the required elements to achieve step-by-step debugging when working in IronRuby Silverlight:

• Visual Studio 2008 RTM (trial version is ok)
• Silverlight 2 Visual Studio Tools - available here (you'll have to uninstall any already installed Silverlight runtime or SDK first)
• Grab the latest dlls from the Dynamic Silverlight SDK and place them under your app folder (or under the chiron /bin folder)

Then add the following to your html file:


<param name="initParams" value="debug=true, reportErrors=errorLocation" />


To actually debug, here are the required steps:

• open your ruby file in Visual Studio
• enable the breakpoint
• attach the debugger to your browser window process
• go back to the browser and hit F5

Here's a screenshot:

(many thanks to Jimmy Schementi for helping out on the ironruby-core list).

If you are still here and like Ruby, you may also want to check out this ruby and rmagick visualization mashup I did to display Velib (Paris bike rental system availabilities.