A simple solution is DeferRefresh() method, postpone useless refresh and will show last one.
Sample code might be:

ICollectionView dataView = CollectionViewSource.GetDefaultView(listBox.ItemsSource);
using (dataView.DeferRefresh())
{
   dataView.SortDescriptions.Clear();
   SortDescription sd = new SortDescription(newField, ListSortDirection.Ascending);
   dataView.SortDescriptions.Add(sd);
}

source: CollectionView.DeferRefresh() : My new best friend

Technorati tags: WPF,CollectionView,CollectionViewSource

It happens also to move VMs from one disk to another (brabd new 3TB hard disk ) or pc-to-pc.

This post in Virtual Box forum is really usefull: How to move a VM to another disk (same machine), this post has helpfull step-by-step instruction.

Here I copy them briefly, but remember to read full post

1.) Copy your “VirtualBox VMs” folder from its current location which is “C:\” to any location you desire. (Remember,Do not delete yet. Only copy,just incase.)

2.) Change your “Default Machine Folder” to the new location.

3.) Now go back to your VirtualBox Manager. Right click on your Guests and click “Remove”. It’ll pop up with 3 options, IMPORTANT: Click on “Remove only”. (Remember,Do not delete anything yet).

4.) Now close your VirtualBox Manager. And then Right click on toolbar “Start Task Manager”. Inside Task Manager, go to “Processes”…. Check to see if “VBoxSVC.exe” is still running…. If yes, click on it and “End Process” …If no,it has timed out and you’re good to go. F5 to refresh your desktop.

5.) Open your VirtualBox Manager again. Go to “Machine,Add”. Your new location should be there automatically. If not, just locate,Then use the add feature to add your guests back one at a time. (select the *.vbox file).

Hope it helps

Next step: and what about a vdi with snapshots?

Technorati tags: VirtualBox

Because every developer is lazy, I was looking for a elegant way to use reflection and Expression, and found this ReflectionUtility that was the right one for me: How to get C# property names without magic strings – static reflection.

You can call it this way:
ReflectionUtility.GetPropertyName(() => myOrder.CustomerCode);

This post worth a read: How to get C# property names without magic strings – static reflection

IBM RoadRunner started in 2008 and now it became too expensive to run, but it’s still in top 25 (#22) .

Current supertcomputer give us double petaflops per watt performance/cost, compared to RoadRunner.

Hei, what’s the powerbill this month?  :(

But it’s life isnt’ ended at all, his electronic parts will be analyzed for future supercomputers’ projects.

source: World’s top supercomputer from ‘09 is now obsolete, will be dismantled

Technorati tags: Parallel

Sono poche pagine, neanche 50, ma cariche di aiuti e informazioni; un libro essenziale e pratico.
L’autore ripercorrre i passi necessari per attivare l’integrazione fra TFS-Project Server (e Sharepoint), sia in caso di nuova attivazione che di upgrade;
c’è anche una requirement-checklist sui componenti e versioni corrette, e sui componenti extra che facilitano la gestione ed ovviamente sono “caldamente consigliati” (es Active Directory, Backup).

L’esposizione è chiara e semplice, una guida passo-passo, con tanto di indicazioni precise, a menu-checkbox-campi da selezionare/cliccare, per tutta la procedura.

Ci sono anche molte note che chiariscono i piccoli errori che possono essere commessi (es: non mettete lo spazio fra …) e che, in passato, ci richiedevano di tornare sui nostri passi per risolvere piccole&grosse “noie” che si presentavano di volta in volta.

C’è anche una sezione riguardante la configurazioni di permessi e sicurezza per utenti, service account e accesso ai database, che infatti è segnalata come “Must know”.
E’ presente una tabella richiesta/intervento che aiuta a capire quali sono i punti di intervento (TFS, Project Server,…) in funzione della esigenza.

Infine, è presente una sezione con script Powershell e link per approfondimenti su argomnti ed applicativi citati nel libro.

Una piccola nota a margine: mi sarei aspettato una sezione di troubleshooting, anche non esaustiva;
tutte le indicazioni presenti nel libro lavorano nella direzione di ridurre le occasioni di errore, ma forse per sarebbe stato utile un aiuto nell’analisi delle problematiche per orientare il lettore nella giusta direzione di ricerca&soluzione.

Buona lettura

Technorati tags: TFS, MS Project

Beh, questa è la volta buona per rompere il ghiaccio
Anche stavolta non mancherà una recensione sul nuovo libricino.

Technorati tags: TFS,MS Project

I wasn’t interested in GPU’s parallel area, but this book gave some interesting ideas about parallel programming, opportunities to take on day-to-day electronic devices.

Here are just 2 of many things I found interesting:

Thread granularity:
An important algorithmic decision in performance tuning is the granularity of threads. It is often advantageous to put more work into each thread and use fewer threads. Such advantage arises when some redundant work exists between threads.

Amdahl – Gustafson laws:
Amdahl’s law often motivates task-level parallelization. Although some
of these smaller activities do not warrant fine-grained massive parallel exe-cution, it may be desirable to execute some of these activities in parallel
with each other when the dataset is large enough. This could be achieved
by using a multicore host and executing each such task in parallel. This is
a illustration of Gustafson’s Law, which states that any sufficiently large
problem can be effectively parallelized. When the data set is large enough
and the more demanding calculation has been parallelized, one can effec-tively parallelize the less demanding calculation. Alternatively, we could
try to simultaneously execute multiple small kernels, each corresponding
to one task.

Amazon.com:

Multi-core processors are no longer the future of computing-they are the present day reality. A typical mass-produced CPU features multiple processor cores, while a GPU (Graphics Processing Unit) may have hundreds or even thousands of cores. With the rise of multi-core architectures has come the need to teach advanced programmers a new and essential skill: how to program massively parallel processors.

Programming Massively Parallel Processors: A Hands-on Approach shows both student and professional alike the basic concepts of parallel programming and GPU architecture. Various techniques for constructing parallel programs are explored in detail. Case studies demonstrate the development process, which begins with computational thinking and ends with effective and efficient parallel programs.

Teaches computational thinking and problem-solving techniques that facilitate high-performance parallel computing.
Utilizes CUDA (Compute Unified Device Architecture), NVIDIA’s software development tool created specifically for massively parallel environments.
Shows you how to achieve both high-performance and high-reliability using the CUDA programming model as well as OpenCL.

Technorati tags: MPI, CUDA, Parallel, Parallel Computing, GPU, GPGPU

They seemed to be different, the second better than the first .. but they are not!
Here is an article where Yuan Shi tell us the history, why they are not so different, plus some maths

Reevaluating Amdahl’s Law and Gustafson’s Law

If you’re new tow parallel computing theory, then better have a read.
Enjoy it!

You cannot parallelize everything, and even if you can do it, you need to coordinate, orchestrate … and other silly things that will settle down your theoric speed up.

First of all, you need to know a very famous rule: Amdhal’s law.
Very simple: a parallel application, is composed by a serial part and a parallel part; the more processors you get, the shorter will be the parallel part … but the serial part will always be there;
so if you want to know the speed up (“full serial app” vs “parallel app”), keep in mind the serial part of parallel application will settle down your hopes

Here is a video explains better Amdahl’s law, by Douglas Eadline – Linux Magazine : Understanding Parallel Computing: Amdahl’s Law

And, the 2nd part, the Lawn mower law, same author: Understanding Parallel Computing (Part 2): The Lawn Mower Law

Technorati tags: Parallel,Parallel Computing

I was very beginner in early steps, and after searching a while for the right doc to start from, I found this introduction essay about parallel computing here: Introduction to Parallel Computing by Blaise Barney .

Barney makes easy to understand different types of parallelism (shared memory, thread, etc), and what they are releated to.
The chapter I liked most is “Designing Parallel Programs”, about partitioning, balancing, communications, granularity
It helps you in early steps, while defining your application’s architecture.

Enjoy it!

source: Introduction to Parallel Computing

Technorati tags: MPI, Parallel