Apache Pivot is a very interesting new RIA platform.  You can think of it as a competitor to Flex, Silverlight, and JavaFX.  Unlike all three of those languages, it uses Java and XML – two generally familiar languages, to create applications.  It’s structured similar to Flex – it has an XML file that describes an application’s layout and allows enough functionality to create simple and not so simple applications with just XML with embedded scripts.  Unlike Flex, the “code behind” language is straight up Java.  It’s deployment model is just like an applet’s, so it’s ubiquitous.  When you dig deeper, there are lots of little niceties – things that are simple and make sense.  It’s nice to work with.

This post describes how to set up a maven project to build and deploy an Apache Pivot application.  Once Pivot is in the maven central repo (it’s not quite out of incubator as of this writing), then the result of this post can be made into an archetype and contributed back.  The result of this post is is this GitHub repository commit.  (Git is very nifty – the fact that the entire set of files is available from one Git commit id is, well, wicked, as we say in Massachusetts.)

We’ll steal the code from the Pivot StockTracker tutorial, since it will be extended with a graph and used as an example of how and why to use the EventBus in UIs.  The examples will be posted on the EventBus.org blog soon.   I’ll add a blog entry here when the eventbus.org blog post is available.

Start by using the maven quickstart to create a blank Java project from an archetype:

mvn archetype:create -DgroupId=org.eventbus.tutorial -DartifactId=stocktracker
cd stocktracker
mvn install

To populate the example, we can pull the StockTracker sources to the our package in the src/main/java directory and delete the files we don’t need:

mkdir src/main/java/org/eventbus/tutorials/pivot/stocktracker
cd src/main/java/org/eventbus/tutorials/pivot/stocktracker
svn co http://svn.apache.org/repos/asf/incubator/pivot/trunk/tutorials/src/org/apache/pivot/tutorials/stocktracker/ .
rm -rf .svn
rm App.java
rm ../../../../../../../test/java/org/eventbus/tutorial/AppTest.java

According to Maven conventions, only the java code belongs in this directory, so let’s move the other files to the resource directory so that they can easily be picked up from the jar at runtime.  A better practice may be to make image, json, and wtkx directory, or maybe make a main/wtkx directory for the latter, but let’s keep it simple.  The community may come up with better standards for Pivot development with Maven.

cd ../../../../../..
mkdir resources
mv java/org/eventbus/tutorial/*.json resources/org/eventbus/tutorials/pivot/stocktracker
mv java/org/eventbus/tutorial/*.png resources/org/eventbus/tutorials/pivot/stocktracker
mv java/org/eventbus/tutorial/*.wtkx resources/org/eventbus/tutorials/pivot/stocktracker

Change all the packages in the Java files to the new package.

find . -name *.java -print | xargs sed -i -e 's/org.apache.pivot.tutorials.stocktracker/org.eventbus.tutorials.pivot.stocktracker/g'
find . -name *.wtkx -print | xargs sed -i -e 's/org.apache.pivot.tutorials.stocktracker/org.eventbus.tutorials.pivot.stocktracker/g'

(This is why I keep such detailed blogs.  It took me while to figure out that the -e is required on Mac, but not Linux, and I’m sure I’ll forget again, but I’ll remember that I had to do this before.)

The maven default build uses Java 1.3 source, even though Java 1.5 is about to be obsoleted as of this writing, so we’ll have to tell maven to get with the new decade and use  Java 6  (I think Pivot will work for Java 5 too) by adding this before <dependencies>:

<build>
 <sourceDirectory>src</sourceDirectory>
 <testSourceDirectory>test/src</testSourceDirectory>
 <plugins>
   <plugin>
     <artifactId>maven-compiler-plugin</artifactId>
     <configuration>
       <source>1.6</source>
       <target>1.6</target>
     </configuration>
   </plugin>
 </plugins>
</build>

Pivot is not in the central maven repo yet, so we have to install it locally, which means building it first.  The Pivot team is rock solid, pulling and building the project is easy and reliable.  See the BUILD file in the svn trunk for details, but on a Mac using Java 6, it’s like this:

cd ~
mkdir pivot
svn co http://svn.apache.org/repos/asf/incubator/pivot/trunk/ .
export CLASSPATH=~/dev/maven-ant-tasks-2.1.0.jar:~/dev/junit/junit-4.8.1.jar:/System/Library/Frameworks/JavaVM.framework/Resources/Deploy.bundle/Contents/Home/lib/plugin.jar:/System/Library/Frameworks/JavaVM.framework/Resources/Deploy.bundle/Contents/Home/lib/javaws.jar
ant maven-install

This builds all the pivot jars using ant and installs them to your local maven repo.

Now go back to our project and add the pivot dependencies to pom.xml:

<dependencies>
 <dependency>
    <groupId>org.apache.pivot</groupId>
    <artifactId>pivot-core</artifactId>
    <version>1.4</version>
 </dependency>
 <dependency>
    <groupId>org.apache.pivot</groupId>
    <artifactId>pivot-wtk</artifactId>
    <version>1.4</version>
 </dependency>
 <dependency>
    <groupId>org.apache.pivot</groupId>
    <artifactId>pivot-web</artifactId>
    <version>1.4</version>
 </dependency>
 <dependency>
    <groupId>org.apache.pivot</groupId>
    <artifactId>pivot-wtk-terra</artifactId>
    <version>1.4</version>
 </dependency>
 <dependency>
    <groupId>org.apache.pivot</groupId>
    <artifactId>pivot-charts</artifactId>
    <version>1.4</version>
 </dependency>
 <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>3.8.1</version>
   <scope>test</scope>
  </dependency>
</dependencies>

You might not need charts, but I will for the EventBus stuff coming soon.

Now

mvn install

should lead to a successful build.

It would be real nice to generate an executable jar file that has the entire classpath in it so that launching the app is a simple java -jar command.  To do this add the following as a plugin after the compiler plugin configuration shown above:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
   <execution>
     <goals>
       <goal>attached</goal>
     </goals>
     <phase>package</phase>
     <configuration>
       <descriptorRefs>
         <descriptorRef>jar-with-dependencies</descriptorRef>
       </descriptorRefs>
       <archive>
         <manifest>
           <mainClass>org.eventbus.tutorials.pivot.stocktracker.StockTracker</mainClass>
         </manifest>
       </archive>
     </configuration>
   </execution>
 </executions>
</plugin>

Now run build again and launch the app:

mvn clean install
java -jar target/stocktracker-1.0-SNAPSHOT-jar-with-dependencies.jar

Pivot Stock Tracker Built with Maven

We can draw a line from the tip of our pencil to our piece of paper and we have a dot.

We can draw a line from our piece of paper to a person we love and when the person dies we can still have the line that touched the person.

We can draw a line from our piece of paper to a person we love and then move the paper and the line is still touching the person.

We can draw a line from our piece of paper to a person we love and then move the person and the line is still touching the paper.

We can draw a line from our piece of paper to a person we love and then move the paper and the person and the line is still touching the line.

We can draw a line from our piece of paper to the tip of our pencil and we still have a dot.

WE NEED:

a sharp pencil
a person we love
a piece of paper

Similar to the Simple PivotTables in Excel script I wrote a while back, today I needed to do a different type of pivot by hierarchy. I had a flat table of rows which I wanted to group by several columns recursively.

# Given data such as
#
# A       B           C
# ------- ----------- ----
# red     lisbon      cat
# blue    venice      dog
# green   paris       cat
# blue    london      dog
# green   lisbon      fish
# green   paris       cat
#
# Output the following
#
#  cat
#     red
#         lisbon           1
#     green
#         paris            2
#  dog
#     blue
#         venice           1
#         london           1
#  fish
#     green
#         lisbon           1
#
# $list | output-hierarchy "C","A","B"

function output-hierarchy
{
    param($hierarchy,$depth=0)
    if ($depth -gt 5) { return }

    $groups = $input | group $hierarchy[0]
    foreach ($group in $groups)
    {
        if ($hierarchy.length -gt 1)
        {
            # Emit title at this level
            "`t"*$depth + $group.name

            $group.group | output-hierarchy $hierarchy[1..($hierarchy.length-1)] ($depth+1)
        }
        else
        {
            # Figure out how many spaces to right align count
            $spacer=(60-$group.name.length-$depth-$group.group.count.tostring().length)

            # End of the road, count the remaining items that fall into this category
            "`t"*$depth + $group.name + " "*$spacer + $group.group.count
        }
    }
}

Written by Gary Ewer, from “The Essential Secrets of Songwriting” website.
____

Changing key is a great device for injecting energy into a song. Known as modulating, it needs to be done with care, being unpleasantly startling to the listener if it’s done haphazardly. There are several ways to change key, including the “abrupt modulation,” but if you’re looking for a way to ease the song into a new key area, you will probably want to try using a “pivot chord.”

A pivot chord is one that can be understood to be in two different keys, and fulfills a different function in each. To fully understand the concept, it’s good to know about Roman numeral analysis. We identify the various chords within a key with a number, and the tradition is to use Roman numerals. Within the key of C major, the following seven chords are created by building triads (3-note chords) on each note of the major scale:

C (I)  Dm (ii)  Em (iii) F (IV)  G (V)  Am (vi)  Bdim (vii)

As you can see, it’s also tradition to use uppercase Roman numerals for major chords, and lowercase numerals for minor and diminished chords.

As I mentioned, those seven chords are the ones that exist naturally within the key of C major. But those chords don’t exist exclusively in that key. For example, the chord G is the V-chord of C major, but it also exists as a I-chord in G major, a IV-chord in D major, and so on.

To change key by using a pivot chord means that we are using one particular chord, and “redefining” its function to be in a new key. Take the following progression:

This progression starts in C major, and ends up in D major. The Em is the pivot chord, because Em is the one used to change direction. In other words, we can interpret it as being the iii-chord of C major, and also as a ii-chord in D major. Here’s how the Roman numeral analysis would look:

That bent bracket in the middle of the progression is the way theorists show that a chord that was a iii-chord in the old key is going to be reinterpreted as a ii-chord in the new key.

The advantage of using a pivot chord is that it eases the ear into the new key, and gives the listener an opportunity to “adjust”. Here are some more chord progressions that move from one key to another by using pivot chords:

1. From C major to F major:
C  F  G  C  Am  Bb  C7  F (The Am is the pivot chord, being vi in the key of C and iii in the key of F.

2. From C major to A major:
C  F  Dm  G  Am  F  E7  A (The F is the pivot chord, being IV in the key of C and bVI in the key of A.

3. From C major to G major:
C  F  G  C  Am  D  D7  G (The C is the pivot chord, being I in the key of C and IV in the key of G.

Changing key is a useful technique for creating a sense of variety in your song, and also for writing a duet, when the two singers need a melody in a different key to be singable. No matter what the circumstance, your sense of musicianship will tell you if the modulation is working or not. And keep in mind this guideline: in general, modulations upward increase song energy, while modulations downward result in diminished energy. Be careful how you do it!
___________

Gary Ewer has written several e-books to help you improve your songwriting skills. If you’d like to discover the secrets of writing great songs, read more here.

Let’s face it; CASE statements are notorious for causing poor query performance. For certain kinds of simple CASE statements, there may be a more performance-friendly OBIEE alternative – the FILTER function. Like CASE statements, you can use the FILTER function to build a logical column expression. In the Expression Builder, this function can be found under Functions > Display Functions > Filter. Here is an example of how to use it:

Suppose you have two Logical Columns derived from the following expressions:

• Southern Region Units:
  CASE WHEN Paint.Markets.Region = ‘SOUTHERN REGION’ THEN Paint. SalesFacts.Units ELSE 0 END
• Western Region Units:
  CASE WHEN Paint.Markets.Region = ‘WESTERN REGION’ THEN Paint. SalesFacts.Units ELSE 0 END

Instead of using CASE statements, try using the following equivalent expressions involving the FILTER function:

• Southern Region Units:
  FILTER(Paint. SalesFacts.Units USING Paint.Markets.Region = ‘SOUTHERN REGION’)
• Western Region Units:
  FILTER(Paint. SalesFacts.Units USING Paint.Markets.Region = ‘WESTERN REGION’)

The SQL generated by the FILTER expressions will typically perform better than the SQL generated from the CASE statements. The FILTER SQL may look something like this (pretending all the columns come from the same physical table):

SELECT Year,
SUM(CASE WHEN Region = ‘SOUTHERN REGION’ THEN Units),
SUM(CASE WHEN product = ‘WESTERN REGION’ THEN Units)
FROM physical_table
WHERE Region = ‘SOUTHERN REGION’ OR Region = ‘WESTERN REGION’
GROUP BY year

The SQL generated from the CASE statements may look more like this:

SELECT Year,
SUM(CASE WHEN Region = ‘SOUTHERN REGION’ THEN Units ELSE 0),
SUM(CASE WHEN product = ‘WESTERN REGION’ THEN Units ELSE 0)
FROM physical_table
GROUP BY year

The major difference is that the FILTER SQL includes the criteria in the WHERE clause. In most cases, this means that the WHERE clause would run first, constraining the result set before the CASE statements are run, hence the improvement in performance.

Every basketball player needs to know how to jump stop and pivot.

I figured I’d let the actual reason for this post be the header image. It’s my first animation using Pivot, and while the program itself could be better, I found the whole experience pretty fun. (To download for yourself, Google “Pivot StickFigure Animator”) Anyway, I’ll work harder on follow up animations. I attempted to make physics, and I kept forgetting to move multiple things for each frame, so I had to keep going back and redoing it. Originally it was going to end with him trapped, but instead I gave him a seizure and he turned hero on us…crazy what stick figures can do these days !

-Nathan Wood

I have a series of artists that I like to listen to when I am trying to concentrate. I like to listen to something with a continuous looping trip hoppy sort of sound that get the cogs in my own head really revolving.

Among these artists include instrumental hip-hop legend DJ Shadow, experimental band Holy Fuck, as well as the likes of Pivot and Errors. It has to be nothing but instrumental and nothing but the best.

Recently added to that list is Seams.

The solo artist, who sounds like a slightly more chilled out version of Errors, released his debut album earlier this year. It’s called ‘A Juvenile Rush’, and he was kind enough to give it to us for free.

I have been meaning to give the album the Hotcakes treatment for a while. It is a glitchy, electronic collection of sounds that betray the fact that it all comes from fiddling on a laptop.

And now, as though he knows that I am in dire need of some musical brain food, being deep into assignment week, he has released a new single called Nightcycles.

Think DJ Shadow’s ‘Blood on the Motorway’. Think Pivot’s ‘Fool in the Rain’. It is pure class.

It starts with a looping piano riff, which eventually glitches into a slow revolving rhythm as though a bike’s tyres are hitting carefully positioned stones on a dark country road. See what I did there.

Seams- Nightcycles

Seams- Nightcycles

I’m a big fan of the lean startup philosophy.  Applied judiciously, this can save a lot of startups from developing a bloated product that nobody cares about.

While I don’t think the minimum viable product concept can be naively applied to hardware products, I do think that the basic principle of not over-designing the product and testing early and often with real customers are the key to developing a great product and a successful business around it.

One of the key tenets of lean startup is the pivot.  Eric Ries has a great post that explains this concept. The core idea is that when your product isn’t performing in the market, pivot, don’t thrash.  Change direction, but stay grounded in what you have learned.   Take prudent risks. Over time and across multiple pivots, the company could end up in a substantially different place from the  original vision, but it will have done so over multiple iterations with a process oriented approach, always grounded in facts and in customer feedback.

Pivoting is easier said than done. Generally when something doesn’t work, the leadership team does one of two things:

• Prematurely announce the product is a dead loss, and launch a new product development effort to chase the Next Big Thing
• Refuse to give up and doggedly try to get it to work long after all rational alternatives have been exhausted

None of these are helpful.  Abandoning ship prematurely throws away valuable customer learnings and brings the company back to square one, resulting in thrashing.  Doing the same thing over and over again in hopes it will work eventually is a measure of insanity.

The trick is to find the courage to acknowledge there is a problem, take a deep breath, and find a way to do a course adjustment that is solidly grounded on facts and learnings, that will hopefully lead to the right solution.  Easier said than done… but it’s the only responsible thing to do most of the time.

This afternoon I drew the tip of my pencil with itself and the nib of my biro with itself. I drew them in my line drawing book, which makes them the first traditionally representational drawings on its pages. They continue my exploration of the line as a representational tool that joins word to thing, and here the pencil and biro use the paper as a pivot for representation. There’s a little bit missing from the very tip of the pencil and the very end of the biro nib where they join on to the lead and the ink of the drawing utensils themselves. As I drew, I lined the lines up with the edges of the utensils, and as the utensils moved so did the lines.

I’m not sure what I’m doing by calling them beaks. Beaks speak. They open up. Out of them come whistles, and into them go worms, I suppose. You could peck if you had a pencil for a beak, but you couldn’t eat anything. Could you even breathe? You couldn’t whistle. Maybe you could learn to write if you were desperate.

I recently made a blog post about Microsoft Pivot.

Here is your chance to get an invite for the Microsoft Pivot Technical Preview ( http://getpivot.com )

Don’t forget:

System Requirements

Recommended System Configuration: Windows 7 with Aero enabled, 2-GHz 32-bit (x86) processor, 2 gigabytes of random access memory.

Supported System Configuration: Windows Vista with Aero enabled, 2-GHz 32-bit (x86) or 64-bit (x64) processor.

Pivot is supported only on US English-based operating systems with US English date and time formats.

Here we go:

The first 6 comments that request an invite get an invite code. Make sure I can contact you..

(Btw some comments may be held for moderation by wordpress so I’ll try to check my spam folder often ).

UPDATE: invite codes are gone.

Analytic functions are first introduced in Oracle 8i. They have got few functions in new release. The first function which I will discuss here will be LISTAGG. It creates a delimited list within a group. Some times you need to toil hard for this. Most of the times, grouping by and converting columns to rows.

With Oracle 11g R2, all you need is the following.

SQL> select deptno,
  2         listagg( ename, '; ' )
  3         within group
  4         (order by ename) enames
  5     from hr.employees
  6    group by deptno
  7    order by deptno
  8   /

  DEPTNO   ENAMES
---------  --------------------
  10       CLARK; KING; MILLER
  20       ADAMS; FORD; JONES;
           SCOTT; SMITH
  30       ALLEN; BLAKE;
           JAMES; MARTIN;
           TURNER; WARD

You can decide what to append with. The syntax is LISTAGG(column, character).

Prior versions you have to use SYS_CONNECT_BY_PATH for this. The new one looks neat though!

Pivot Function

Pivot function is an important function in data warehouses. Prior to this version, people used a roundabout version to achieve this feature. Check here for the various methods. Most of the time, you want the data to be presented as a tabular form. Consider the following ‘sales’ table.

Product
Channel
Amt Sold


CDROM
Direct
2000


CDROM
Market
45000


CDROM
Internal
300


CDROM
Distributor
3400000


Key Board
Direct
100


Key Board
Market
6500


Key Board
Internal
200


Key Board
Distributor
7845000

Now, if you want to pivot it for the channels, the command would be as the following.

SQL> select *
  2	from
  3      (select product
  4	      , channel
  5	      , amt_sold
  6	    from sales_view ) s
  7     PIVOT (sum(amt_sold)
  8	     for channel in (‘DIRECT’, ‘MARKET’
  9			   , ‘INTERNAL’, ‘DISTRIBUTOR’)
 10	     )
 11   /

PRODUCT     DIRECT     MARKET     INTERNAL     DISTRIBUTOR
----------- ---------- ---------- ------------ -----------
CDROM       2000       450000     300          3400000
Key Board   100        6500       200          784500

The same way, you can pivot it using several attributes. It some cases, if you want to UNPIVOT a PIVOTED table, you can use UNPIVOT (AMT_SOLD, FOR CHANNEL IN (‘DIRECT’, ‘MARKET’, ‘INTERNAL’, ‘DISTRIBUTOR’)).

On Saturday I presented a new work at the Stanley Picker gallery during the Writing Exhibitions symposium. Here’s an outline of my work, which I called Genuine Smiles:

A sheet of paper is attached to one wall of the gallery, and attached just below it is a long piece of string with a sharpened pencil fixed to the other end. Visitors are invited to hold a pencil and do whatever they need to do to muster a genuine smile. As soon as the smile is on their lips and before it vanishes they should begin to draw a line from the smile to the piece of paper, without allowing the pencil to leave the surface, until the line from the smile reaches the most convenient edge of the paper.

The picture above is the piece of paper, which I removed from the wall and kept. Below is the paper on the wall of the gallery, continuous with its lines which also continue onto the floor:



Genuine Smiles follows on from the book of line drawings I made over the summer (more here) in which I recorded places and times by drawing lines from the pages of the book to nearby things. Once a set of lines has been drawn and the book has been put away again, the objects, furniture, walls, floor are still marked with lines, all of which converge about a single rectangular gap.

There are lots of these rectangular gaps lying around the house now. The gaps mark places in the room where the book can be reinserted, with the appropriate pages spread open, to reconnect the detached elements of the record.

The lines drawn in the book are like deictic words, which have a fixed semantic value but a unfixed denotative value (words in English like ‘you’ or ‘here’). The semantics of each line is the way it looks and the way it runs off the edge of the page, and the denotative value of each line is the thing it points at. Taken as a self-contained book, separate from the pencil marks drawn around the room, the references of the lines on the paper are frustrated. You don’t know what they’re saying other than that they mean to say something. Not waving but drowning.

The book that fills all the gaps is safe drowning on a shelf in the hallway at the moment. But even if it returns to one of its rectangular gaps and connects up to each line correctly, the other ends of the lines – the lines touching the objects I wanted to record – are still precarious. As things get rearranged, put away, tidied, nudged, so the lines that reach them splinter and rotate and move until they are pointing somewhere else, or end abruptly, or dissipate in angular ways through the house.

This dissipation returns as the failure of writing as witness that led to the biro line I drew in September, and it comes up again in a different way in Genuine Smiles.

In Genuine Smiles people are invited to draw a line from their smile to the piece of paper on the wall, using a pencil attached by a long piece of string to the paper itself. The line should be drawn continuously along whatever surfaces it takes for the pencil to reach the paper without ever leaving some ground or other. I’ve written before about my intentions for this work, and another day I look forward to writing more about how my intentions affect the work and its participants. But for now I want to focus on the movement of the line itself as it is fractured and carried apart.

I want to think about the line as a visible rendering of the relationship between a word and the thing it describes. The line is constructed from the same stuff writing is constructed from, and because of this the line feels something like an unravelled word. But it stretches and attenuates the possibility of being a word: it doesn’t occupy the same space as a word because it travels to and touches its object, and travels to and touches another object too, which is the piece of paper. At the moment the direction of travel seems less important than the fact that movement takes place. I’m not sure what to make of the piece of paper yet.

The piece of paper stuck to the wall at the Stanley Picker gallery was the place people were asked to draw their lines to. As a result it felt as though the smile was only ‘written down’ once it had touched the paper, and indeed people generally stopped their lines as soon as they’d passed the edge of the page.

Once the line was on the paper the smile was ‘kept’, and while the line was just on the wall, floor, foot, trouser leg, arm, chin or mouth, the smile was still precarious and at risk of evaporating. The line doesn’t change in quality when it reaches the paper, but something changes.

The paper is special because it is temporary and is removable and is the one part that can be kept once the event is over. The wall will be washed over, the people will go home and the lines will be cleaned from their skin and clothes. Perhaps the paper is special because pencils go with paper, so a pencil line is resolved when you conclude it on paper. It’s special also because it’s shared between all the smiles: all of them end there, and so the paper is where all the smiles go to be collected up.

I want to think more about what’s left in the gallery once the people have gone and the paper has gone too. The pencil lines remaining are tethered neither to their endings on the page nor their beginnings at our lips. Just the middle part of the deixis – the blank fact that something’s referring to something. Just smiles in passing.

In a typical data grid, the data is flat and consists of many rows and columns. The data may contain cells with same values and working with the raw data may not be the best way to spot patterns and analyze trends. Many data grid controls provide rows grouping functionality which allows you to group multiple rows by columns where the corresponding grid cells have the same value.

Pivot tables go one step further and enable powerful data analysis. A Pivot table consists of rows, columns and data (value/fact) fields.

VIBlend DataGrid for Silverlight features a built-in data aggregation engine which is capable of turning any tabular data source into a wide variety of cross tab views. This is similar to the Pivot tables functionality in Excel. Creating a Pivot table with VIBlend DataGrid for Silverlight is very easy. In fact, the data binding to the data source is no different than data binding any other control to a collection. Assume that you have a table with five columns: Country, Region, City, ShipperCompany and ExtendedPrice. You need to choose the columns from the data source and add them to the BoundFields collection:

CSharp:

pivotGrid1.BoundFields.Add(new BoundField(“Country”, “Country”));

pivotGrid1.BoundFields.Add(new BoundField(“Region”, “Region”));

pivotGrid1.BoundFields.Add(new BoundField(“City”, “City”));

pivotGrid1.BoundFields.Add(new BoundField(

“Shipper Company “, “ShipperCompany”));

pivotGrid1.BoundFields.Add(new BoundField(

“ExtendedPrice”, “ExtendedPrice”));

Using this code, once you data bind to the data source, the grid will display all table rows and the five columns: Country, Region, City, Carrier, Extended Price.

However, let’s look at a scenario where we want to show count of sales, amount of sales, and average sale amount grouped by Country, by Region and by City, and do that for each Shipper Company.

This requires only a few extra lines of code:

1. Assign the Country, Region and City fields to form the Rows hierarchy:

CSharp:

pivotGrid1.BoundPivotRows.Add(new BoundField(“Country”, “Country”));

pivotGrid1.BoundPivotRows.Add(new BoundField(“Region”, “Region”));

pivotGrid1.BoundPivotRows.Add(new BoundField(“City”, “City”));

2. Assign the ShipperCompany field to form the Columns hierarchy:

CSharp:

pivotGrid1.BoundPivotColumns.Add(new BoundField(

“Shipper Company”, “ShipperCompany”));

3. Assign the ExtendedPrice field to form the facts/values for count of sales, sales amount, and average sale amount:

CSharp:

pivotGrid1.BoundPivotValues.Add(new BoundValueField(“Count of Sales”, “ExtendedPrice”, PivotFieldFunction.Count));

pivotGrid1.BoundPivotValues.Add(new BoundValueField(“Amount of Sales”, “ExtendedPrice”, PivotFieldFunction.Sum));

pivotGrid1.BoundPivotValues.Add(new BoundValueField(“Avg Sale Amount”, “ExtendedPrice”, PivotFieldFunction.Average));

4. Specify if the value/fact columns appear attached to the rows or to the columns:

CSharp:

pivotGrid1.PivotValuesOnRows = false;

During the data binding process, the OLAP engine in VIBlend DataGrid for Silverlight will parse the table content, build the rows and columns hierarchies, and compute the pivot table cell values. The result will be the following pivot table view:

You can learn more and see a Live demo at: http://www.viblend.com

Bij het nieuws over Rupert Murdoch die zijn websites uit de Google wil hebben zodat Bing ervoor kan betalen, kwam toch echt een associatie met de dinosaurus boven. Zo groot gegroeid dat je ten onder gaat aan je eigen gewicht. Dat laatste kun je natuurlijk ook denken over Google (ook errrrug groot), maar iets tegenwerken zoals meneer Murdoch wil  is niet de manier om iets te veranderen, nieuwe mogelijkheden bieden gaat veel sneller,  zoals bijvoorbeeld Google al een tijdje doet.

Neem oranje wol en de nieuwe (Starwars-)muts voor de deelnemers aan Kadenski-2010 is helemaal gereed.
Wie kan er goed breien?

Een totaal ander onderwerp en mogelijk meer iets voor de deelnemers aan het kcc-programma, maar ook de gemiddelde consultant heeft er iets aan als ie wat weet over teamvorming.  En als je via via toch op wikipedia bent belandt kun je daar meteen opzoeken wat een paradigmaloog is, al die moeilijke woorden ook.

Oracle kan meer dan alleen maar tabelletjes opslaan. En ze zijn zelf niet eens de enigen die dat vinden, er zijn er meer die opmerken dat Oracle goede producten heeft, ook op planningsgebied bijvoorbeeld.

Schaamteloos plagiaat plegend van het intranet, maar misschien is niet iedereen daar al geweest, is het opmerkelijk te zien dat de vernieuwingen echt niet alleen van Google komen. Al lijkt het er op dat Microsoft wel een beetje leentje-buur heeft gespeeld voor de werkwijze. Voor iedereen die het nog niet gezien heeft: Microsoft is druk bezig met iets wat ze Pivot hebben genoemd en het heeft wel degelijk raakvlakken met BI.

Van een van onze correspondenten: Gratis reporting is wat de klok slaat

Een van de manieren waarop Oracle/Sun de exadata database machine snel maakt, is door gebruik te maken van wat ‘Flash Cache’ genoemd wordt. Er zijn inmiddels manieren aan het opduiken om stukken van die versnelling ook beschikbaar te maken op ‘gewone’ hardware. Poor man’s Exadata zeg maar.

Vooruit, een uitsmijter dan maar. De voorbereidingen voor de nieuwe editie van de Top 2000 zijn alweer begonnen. Hoe je van een ouwe koe toch weer iets leuks kunt maken laten de muppets maar nog eens zien.
Nu hopen dat er dit jaar iets vernieuwends op nummer 1 staat.

Pivot Legal Society in Vancouver has launched a new campaign entitled, Homelessness is over.

The site implores Canadians to write to our very own (styling) federal minister of Human Resources and Skills Development Diane Finley.  The message reads as follows:

Dear Minister Finley,

I am adding my name to the movement to end homelessness in Canada.
Canada is the only G8 nation without a national strategy to ensure everyone has access to quality, affordable housing. The result? A growing homelessness crisis that the UN has described as a “national emergency”.

Bill C-304, An Act to ensure secure, adequate, accessible and affordable housing for Canadians, would help put an end to this national shame.
I am asking Pivot Legal Society to carry my voice to Ottawa and demand you do your job and create a national housing strategy NOW!

* Remember – all letters to Parliament Hill do not require any postage.

Hon. Diane Finley - Hill Office

VIBlend is proud to announce the release of a new OLAP Data Grid Control for Silverlight

VIBlend DataGrid for Silverlight is the first grid control that brings together the functionality of traditional data grids, hierarchical grids and pivot tables. This feature complete control includes a built-in OLAP engine which can easily process data in tabular format and aggregate it based on user defined criteria.

Getting started with VIBlend DataGrid for Silverlight is easy and it takes very little code to implement complex scenarios from end to end.

VIBlend DataGrid for Silverlight is one of the fastest Silverlight grid controls and can easily work with large number of rows.

VIBlend Silverlight Controls are written entirely in C# with the latest .NET technologies.

To learn more and download your free trial copy of VIBlend Silverlight Controls, visit http://www.viblend.com

Pivot is a new project from Microsoft Live Labs that looks very promising. It’s a system and interface for displaying and filtering large sets of information. From the Pivot website:

“Pivot makes it easier to interact with massive amounts of data in ways that are powerful, informative, and fun. We tried to step back and design an interaction model that accommodates the complexity and scale of information rather than the traditional structure of the Web.

When we use the Web today we treat the most fundamental scenarios as separate activities. Search takes us from many things to one, browsing moves us from one thing to another, and recommendations expose affinities that enable us to explore related topics. Can we do better by combining these scenarios into a more unified experience?

Pivot focuses on this intersection, enabling us to learn key lessons while attempting to broadly apply this philosophy to the Web. We hope that Pivot will inspire and fuel transformative experiences across the Web.”

That last bit is particularly interesting –the intersection of browse and search in particular. Of course, I wrote an entire chapter in Designing Web Navigation on integrating browse and search (see Chapter 11). There, I focused on more microscopic UI elements and techniques that web designers could readily implement. But at the heart of my argument is the fact that fundamentally, from an information seeking standpoint of the user, there really is not difference between browsing and search: people just want to find information.

Facetted search takes up a big chunk of Chapter 11 in DWN. And a good part of Pivot is an extension of faceted navigation. It’s really a big filter system using different facets–but a way more powerful way to do it, in what appears to be a much more direct and satisfying experience.

Notice also that the creators of Pivot talk about emotional connections and information experience in the trailer video. This is also something that distinquishes Pivot from other such inventions, I believe.

So, Pivot doesn’t appear to be a niche, scientific experiment with limited practical use. I think there are some quite valuable aspects to Pivot that hint at things to come. I’ll be interested to see where it goes.

By Ron Sirak
Golf World

A year ago, Annika Sorenstam was picking up the pieces. She and David Esch had filed for divorce Feb. 4, 2005, after a stormy 14 months in which they tried to decide whether their relationship was worth saving, a stretch that spanned a tear-filled 2004 in which she remarkably won eight LPGA events. Asked whether her life is better now, Sorenstam laughs and says, “Yes, a lot better.”

With the same discipline she uses to put a poor shot behind her, Sorenstam has moved on. In Mike McGee, a 31-year-old agent for International Golf Partners and the son of four-time PGA Tour winner and 1977 Ryder Cup team member Jerry McGee, she has found a friend she says “really looks out for my best, and he knows all about what I do since he grew up on the tour.” Sorenstam’s divorce was finalized Aug. 22, and shortly thereafter, doctors were able to sort out a mysterious hip problem that had obstructed her pivot much of the year.

“I met with doctors after returning home to Orlando [in September], and they fixed it, even though it took them four sessions,” Sorenstam said. “They used a new therapy called ‘Body Talk’ and told me I probably got the problems in my hip because of the things I’ve gone through in my personal life. It was a mental thing that made me fragile in a physical way. All was fine after September. I can swing the clubs like I want now.”

The injury, in which a bone moved in her right hip, could explain why she won only once in eight tournaments — starting at the U.S. Open — after six victories in her first eight starts. After treatment, Sorenstam closed the year by winning three of her last four tournaments — a stretch that began at the Samsung World Championship, the first event in which Michelle Wie competed as a pro.

Sorenstam, 35, is coming off a 10-win season and a five-year stretch in which she has won 43 times and pushed her career total to 66 victories, trailing only Mickey Wright (82) and Kathy Whitworth (88). An athlete who loves a challenge, Sorenstam once again is dangling the Grand Slam as the carrot she is chasing. By the end of last season, she also seemed to be gaining motivation from younger competitors. She won by 8 in Wie’s debut and dispatched Paula Creamer in the ADT Championship after Creamer twice challenged her on the rules in the first round.

In another display of letting go of the past, Sorenstam, the team captain, paired herself with Creamer in the Lexus Cup in December.

“She didn’t want [the situation] to linger,” one Sorenstam friend said. “She wanted to end it right there.”

Sorenstam teamed with Liselotte Neumann as Sweden won the Women’s World Cup last month, then left for her Nevada home to ski and relax. She will skip the first two LPGA tournaments of the new season and make her first start March 10-12 in Mexico at the MasterCard Classic, where she is the defending champion.

Pivot makes it easier to interact with massive amounts of data in ways that are powerful, informative, and fun. We tried to step back and design an interaction model that accommodates the complexity and scale of information rather than the traditional structure of the Web.

[ source ]

Some videos:

It’s funny to see that Google “suddenly” created a new application called Image Swirl because Microsoft announced Pivot.

Oh because we are talking about images. I just came across this movie about CSI. Nice to see that they bring real technology (aka Photosynth) to the screens:

I decided to make a blog, but this is now my main site, other than ThePivotPlace.

I watched a good bit of the PDC 2009 webcasts last night and found there are some interesting technologies coming out. I don’t think it comes as much of a surprise that Microsoft is cramming Azure and Silverlight down developer’s throats. There were also talks of IE 9 (don’t worry they are just starting development) and Visual Studio 2010. In my opinion Visual Studio 2010 is a game changer in development if they can get the performance up and memory requirements down. The top feature in, in my opinion, is the historical debugging capability in IntelliTrace, which allows a snapshot call stack to be taken in a different environment and then allows a developer to open that snapshot and step through the source code right on their desktop.

All that aside, there seems to be an increased focus on data this year and a multitude of code name and product name changes. I want to provide an overview of my understanding of the recent items that were discussed at PDC 2009 relating to data.

• Windows Azure Tables and Blobs are a way to store data in the cloud. When that wasn’t enough Microsoft moved to Azure SQL Data Services. This technology allowed users to store data in SQL tables and was extremely scalable. Apparently the public doesn’t care about scale because they want relational. So Microsoft has renamed the offering to SQL Azure. The primary differences are that now you can actually use SQL Server Management Studio to connect using the (Tabular Data Stream) TDS protocol and you can use relational queries.
• Oslo was a metadata framework for managing data and has now been boiled down to M and Quadrant and now falls under a larger umbrella of SQL Server Modeling Services. Honestly I can’t quite see the compelling argument for this yet unless you are a DSL (domain specific language) designer.
• Astoria was a REST based data access service. It was renamed to ADO.Net data services and recently changed to WCF data services. The new name change also introduced OData, which sounds like the new ADO.Net (yes, yet another data access technology).
• Dallas is a new data service from Microsoft intended to create a market place for data, the new commodity (I guess this is Microsoft’s answer to Apple’s iTunes and App Store). There are some public data sets available already for free. It seems the intention here is to enable innovation using data.
• Pivot from Microsoft labs was one of the more compelling things I saw. It is essentially a new Internet browser that has an extension for understanding another new data format called Collection XML (cxml). The viewer uses Silverlight and DeepZoom to visualize data.
• LINQ to SQL was a compelling technology that abstracted developer from writing T-SQL code by using an ORM (object-relational mapper). However, it seems tying this technology to SQL Server was not popular with the real world and Microsoft has been strongly advising against using it. In the 4.0 version of the .Net framework Microsoft placed this technology within the ADO.Net Entity Framework (EF) and calls it “Direct Mapping”. The EF also supports mapping at a more abstract level using an Entity Data Model (EDM) and a raw schema, should that be desired.