I får her muligheden for a se eller gense de 3 præsentationer fra vores indlægsholdere: Henrik Theil, Kommunikationschef v. FDIH, Kristina Risom Jespersen, Associate Professor, Aarhus Universitet og John Field, European Product Marketing Manager, Sitecore.

Vi fik et godt indblik i danskerne som digitale forbrugere og hvilke platforme og kanaler der vil være de fortrukne i forhold til den financielle sektor. Desuden så vi på hvordan bankerne kan gøre brug af deres kunders input via sociale medier og vi oplevede konkrete eksempler på dette. Til sidst fik vi et levende eksempel på hvordan den rigtige platform kan være med til at gøre et website mere engagerende og værdiskabende for slut kunderne.

Download præsentationerne her:

Danskerne som digitale forbrugere (Henrik Theil, Kommunikationschef v. FDIH)

Hvordan er kunderne online – og kan de hjælpe til udviklingen af fremtidens bank? (Kristina Risom Jespersen, Associate Professor, Aarhus Universitet)

Engage with your customers (or how Alice decided to invest) (John Field, European Product Marketing Manager, Sitecore)

Hvis dette har vagt jeres interesse og I kunne tænke jer en uforpligtende snak om hvordan I kan komme igang og styrke jeres digitale bankforretning, tilbyder Valtech en gratis 3 timers workshop hvor vi tager et nærmere kig på jeres forretning og de konkrete udfordringer i står overfor i forhold til den digitale forretningsudvikling.

Kontakt Morten Sørensen, Business Development Manager, Valtech på morten.sorensen@valtech.dk for en uforpligtende dialog.

De bedste hilsner,

Valtech

Vi giver jer nu muligheden for at gense Joacim Jeppesens (Director, Sales & Market Development, Valtech) indlæg, hvori han præsenterer Valtech’s perspektiv på, hvordan de digitale kanaler har ændret spillet radikalt for virksomheder, og i særdeleshed deres marketingafdeling. Indlægget giver dig indblik i vores tilgang til en digital orienteret kundeoplevelsestrategi, som må sige at være yderst relevant i dag.

Click here to view the embedded video.

Det er også muligt at downloade både Joacims og Gunnar Klaubergs (Evangelist, Customer Marketing, Adobe) præsentationer fra dagen:

From CRM to Customer Experience Management (Joacim Jeppesen)

The Digital Marketing needs in a new reality (Gunnar Klauberg)

Hvis der skulle være nogle spørgsmål til indlægget eller præsentationerne, så kontakt gerne Joacim Jeppesen på joacim.jeppesen@valtech.dk.

God fornøjelse og på gensyn til vores næste seminar!

Med venlig hilsen

Valtech

Der er 3 virksomheder i Danmark som er GA Analytics Partner certificeret. IIH, Guava og os Valtech. I Valtech kan vi takke Lars Gundersen for at Valtech er med til dette specielle og lidt besynderlige arrangement. Det er specielt, fordi vi kun er nogle få indbudte fra hele verden der er med. Besynderligt fordi vi stort set ikke må fortælle noget til nogen,  om alle de nye features, ideer og produkter som Google arbejder med i deres analytics portofolie. Så vi, de udvalgte, er selvfølge privilegeret i at få forhåndsviden om deres nye produkttiltag.

Vi er på den hemmelige Google og dermed analytics forkant

Vi er på forkant. Men hvad kan jeg egentligt fortælle når det nu er så hemmeligt? Og hvordan kommer jeg igennem med budskabet uden at jeg kompromitterer vores gode forhold til Google?

Det skal siges at jeg i forvejen er stor tilhænger af Google, deres metoder og måde at tænke på. Jeg har arbejdet med Google i 6-7 år, hvor jeg har specialiseret mig i SEO & SEM og benytter analytics til at prædike om at virksomheder kan få kæmpe indsigt i deres marked, og lære deres kunders adfærd på nettet bedre at kende.

For at få lidt kød på historien har jeg måttet tale med et par officials fra Google. Jeg tog programmet og gennemgik hvad der var Ok at formidle og hvad der absolut var ”no go”. Som det ses var der 4½ historie som jeg slet ikke må nævne heller ikke i overskifts form.

Indsigt som den største udfordring.

Her på den første konference dag har vi, uden sidestykke, hørt om Googles Digital Marketing Evangelist, Avinash Kaushik’s kamp med at få store corporate virksomheder til at indse hvad de kan med web analytics.

Avinash er åbenbart en forkæmper for det vi kender som Web 2.0, altså at der bag internettet sidder en masse rigtige mennesker med reelle og naturlige behov for information, viden og ønsket om at gøre hverdagen nemmere. Hans mission er bl.a. at få beslutningstagere til at indse hvordan de på en let tilgængelig måde kan få viden om deres marked og imødekomme deres kunder på en langt nemmere og transparent facon. Alternativet er, som Avinash beretter, at fortætte business-as-usual  og dermed blive ved med at gemme sig på direktionsgangen og baserer sine beslutninger på 2. håndsinformation, som er typiske inden for traditionel marketing og management consulting.

The Google way

Her på dag 1 har vi bl.a. også hørt om hvordan Google arbejder med produktudvikling og Innovation hvor de fortæller os om processen fra 0-100 når et nyt produkt skal udvikles. At høre om Googles udviklingsmetode er i sig selv interessant og kan bruges i mange andre sammenhænge for andre virksomheder og organisationer ja, måske politikere, når de skal udvikle nye services og knække nedadgående kurver.

 Mulitchannel analytics

En af Googles nye features som bruges til at finde ud af, hvordan vi brugere og kunder finder frem til en given virksomheds produkt hedder ”Multi-Channel funnels” (som vi kalder det herhjemme i Californien :>

Formålet med værktøjet er bl.a. at kigge på hvor mange forskellige kanaler vi benytter når vi skal finde ind til selve website. Den viden kan bl.a. bruges til at justerer trykket i den enkelte kanal og i det hele taget at få viden om hvilken adfærd brugeren har når han fx gerne vil købe virksomhedens produkter.

Hvis det fx viser sig at vi har klikket på et banner, men ikke købt for siden hen at søge mere information igennem en søgemaskine som fx Google – vil det fortælle os at banneret har været medårsag til det egentlige køb. Derved får det udskældte banner en ny betydning. Om vi så også kan finde ud af om banneret blot er blevet vist og brugeren ikke har klikket på banneret, ja det vil så jeg forsøge at finde ud af.

Web Analytics som Business Intelligence

I det hele taget er web analytics møg spændende og måske vil denne form for data indsamling kunne bruges i egentlig ” business intelligence” hvor vi om få år også begynder at kombinerer digitale enheder som mobilen og måske endda digitalt TV for derigennem at få viden til at kommunikere bedre og mere præcist med hinanden.

Fordelen er indlysende i stedet for at træffe vores beslutninger på antagelser og få stikprøve analyser ved fx traditionelle telefoninterviews som vi eksempelvis kender det fra Gallup, vil vi med denne form for analytics få konkret viden på baggrund af egentlige tilkendegivelser. Viden i form af konkret adfærd enten på en webside, fra mobilen eller måske endda fra fjernbetjeningen.

Jeg glæder mig i hvert fald til dag 2 :>

Lysene Google isterninger

Det er 4 gang at Valtech deltager og denne gang er det Martin Stahl og Mig selv Lars Gundersen der er med. I år skal det desværre ikke holdes på Google campus, som de andre år, men på Computer History museum. Der vil også blive afholdt Web analytics wedensday i løbet af ugen som Google selvfølgelig sponsorer.

Vi vil forsøge og komme med lidt fagligt indhold, selv om alt på eventet er Top Secret.

Vi kan også følges løbende på Twitter.

Lokation:

Gik du glip af det? Så tilmeld dig vores eksklusive Rise & Shine morgenmøde den 29/9-2011, hvor eksperter fra inRiver og Valtech vil give dig et indblik i, hvordan I kan komme i gang med product information management på et strategisk og taktisk niveau.

Click here to view the embedded video.

Where can this be applied and what’s the benefit?

Imagine you have to implement a widget for a website. The widget has to be loaded dynamically at an arbitrary point in time after the page has loaded. Also imagine that the widget needs data from two different data sources before it can be rendered out. On top of that you have already decided that you are using a jQuery templating enigine on the rest of your site and for consistency you want to use templating for the widget as well.

So what are we looking at here? Well, the data needs two requests – one for each datasource. It might also make sense to load the template for the widget dynamically meaning one more request. That means we have to make three ajax requests in total before we can render our widget. Actually it’s not enough to make the requests. You have to make sure that they have all finished before starting the rendering process. Now, that is by no means a huge problem to solve but Wajax will help you out and make it very easy to handle this situation.

For more information about how that actually works I suggest you check out the documentation on the project’s GitHub page which can be found here. Hopefully you will also download the plugin and check out the included example.

It’s worth noting that the first version of this code was actually created to solve a specific need for a website we created for a client. After the website was launched Valtech invested some time in packaging the code into a small jQuery extension, documenting it and putting it out there on GitHub.

Why jQuery and why Open Source?

At Valtech we have made a strategic choice to go with jQuery for the front end development in our web solutions. In reality there weren’t that much of a choice to make as jQuery has become the de facto market leader when it comes to javascript frameworks for frontend development. It’s the javascript framework that everybody knows and it has a huge backing in the open source community. Even Microsoft is including it in their MVC framework.

Just as we made the choice of using jQuery in Valtech we also decided it was time to join the Open Source community. We get huge benefits from using and learning from all the Open Source stuff that’s out there. This we way we can pay back a little to the community.

Off course, we also believe it makes sense from a business point of view. For instance, when we need to build something that’s not already out there in the Open Source community we could choose to put that into our own library. However, when it comes to frontend development the world is moving very fast. Next time we would need to use something similar we would still have to search the Internet to see if something better had come up in the meantime. Chances are that something close would have been built by somebody else facing the same need as we did – and their code might already have gained a following. That quickly makes maintaining your own “private” library of code seem a bit redundant.

That’s why we have opted to share some of the more general frontend components we develop in-house. Our hope is that you will prove this to be the right decision by using and contributing to the components we release as Open Source starting with the Wajax for jQuery extension.

Our solution to this problem is achieved primarily by the use of NAnt ¹ and some extensions we have built on top of that. Our setup allows us to support different configurations on not only a per-environment basis, but also on a per-machine basis in each environment. Our solution is stand-alone, not requiring any external references, and it is easy to setup. Best of all? We are offering it to you, free of charge! A download link for an example project can be found at the bottom.

Let us dive right into it and take a look at an example project setup, see the figure below:

The interesting bit here is the “Valtech.ConfigFramework” project. The project is divided into a number of folders:

• configfiles/dynamic: This holds all the files that needs to be dynamically altered based on the target environment and/or machine.
• configfiles/include: This holds all configuration properties for each target environment and/or machine, needed to alter the files in “configfiles/dynamic”.
• configfiles/static: This holds all files that need to be included for a specific build configuration, but does not need to be altered, e.g. license files.
• framework: This holds all necessary files needed.

When building the project, the include files are merged with the dynamic files, and output along with any static files to the output folder( s). The actual folder structure looks like this:

Here, there is only one application named “ConfigFrameworkTestApp”, but you could have any number of applications using the same Valtech.ConfigFramework.

Dynamic and static files

In the previous solution overview, I showed an application alongside the configuration framework. In the figure below, two folders “License” and “Log” have been added to the application, and the “configfiles/dynamic” folder and “configfiles/static” folder for the Valtech.ConfigFramework project have both been expanded:

As you can see, there is one top-level folder below the “configfiles/dynamic” folder named “ConfigFrameworkTestApp”. This is simply the name of the application being targeted (see the physical folder structure figure above). One level below the application folder is a folder named @Log. Files from the ConfigFramework project are output to the application root directory, and the prefix @ tells the ConfigFramework to copy any files in this folder to the corresponding folders in the application

Below the “configfiles/static/ConfigFrameworkTestapp” folder there are three folders: development, prod and qa. These folders each act as containers for files specific to an environment. In the figure above, the qa-environment folder is expanded, and below this folder is a folder named @License containing a license file specific to this environment.

So in this case the following files are copied from the ConfigFramework project to the application:

The files from the dynamic folder, are altered based on configuration properties from the “configfiles/include” folder (more on this below) whereas the static files are simply copied to the application.

In this example we are only modifying and copying .xml and .txt files, but the ConfigFramework is not restricted to working with any specific file types, so you could for example add external .dll files as static files to be copied.

Include files

Now that we have an idea of what is going on, let us take a look at some actual examples. First take a look at the following figure:

As you can see, the “configfiles/include” folder is expanded, once again revealing the application “ConfigFrameworkTestApp” as the top-level folder. Below that there are a number of folders: development, prod and qa, each used for targeting a specific environment. However, as evident below the “configfiles/include/ConfigFrameworkTestApp/development” folder (which holds all properties for configuring the application in the development environment), there are two more folders: dk-lt-jani64 and dk-lt-jeth64. These are both actual machine names, and any properties defined for a machine will automagically override properties defined on the environment (i.e. development in this case) level.

Sounds confusing? Hopefully not so much if we look at an example. Below are a few lines from the App.config of the application:

<appSettings>
    <add key="HelloWorld" value="${HelloWorld}"/>
    <add key="GlobalWorld" value="${GlobalWorld}"/>
</appSettings>

And next are the contents of the configfiles\include\ConfigFrameworkTestApp\development\developer.properties file in the Valtech.ConfigFramework project:

<?xml version="1.0" encoding="utf-8"?>
<target xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">
  <property name="HelloWorld" value="Hello World. I'm from development"/>
</target>

Notice the property with the name “HelloWorld”. When you build the Valtech.ConfigFramework, the value of this property will automatically replace the ${HelloWorld} token in any files under the configfiles\dynamic folder. Now, what if my personal HelloWorld value differ from the general development settings? Answer: I simply override the property in my machine specific developer.properties file – i.e. configfiles\include\ConfigFrameworkTestApp\development\dk-lt-jani64\my.properties:

<?xml version="1.0" encoding="utf-8"?>
<target xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">
  <property name="HelloWorld" value="Hello World. I'm from my own machine"/>
</target>

But the ConfigFramework is not restricted to simply having key-value pairs. Supposing you only want to include parts of a Web.config for specific build configurations, and not others, you can do that too. For example, if I include the following line in my App.config file:

${SMTP}

The ConfigFramework will look for a SMTP.property file under “configfiles/include”, and replace the line above with the contents of the file, e.g.:

<system.net>
    <mailSettings>
        <smtp>
            <network host="mailserver.mydomain.com" />
        </smtp>
    </mailSettings>
</system.net>

Putting it all together

So how does all this work? The keen eyed reader may have noticed a number of .cmd files in the figures above, and this is where all the action is happening. Well, that and solution configurations in Visual Studio.

The figure above shows the different solution configurations for this solution. Depending on the active solution configuration, the application@environment (in this case ConfigFrameworkTestApp@development) will be built by calling the application@environment.cmd file. To create a new configuration, you simply need to copy one of the existing application@environment.cmd files, and rename it according to your Visual Studio solution configuration.

Wrapping things up

This solution, allow us to automatically build configurations for any number of environments and machines. It does require some initial setup, but once that bit is over, you don’t ever have to worry about manually merging config files from one environment with another. Secondly, if you pair this approach with a continuous integration package (e.g. TeamCity) you can automate the entire process of building and deploying your applications across multiple environments.

Now, for what you’ve all been scrolling to:

Make sure to replace the folder names “your-machine-hostname” with the name of your machine and try to play around with the different build configurations:

• ConfigFrameworkTestApp@development
• ConfigFrameworkTestApp@prod
• Manual configuration update

The first two work as explained above, where as the third “Manual configuration update” bypasses the configuration builder which is useful if you would like to build your application without also building all configuration files.

Notes:

1. NAnt is a (free) .NET build tool based on Apache Ant, designed for developing software across multiple platforms. There are tons of examples on how to use NAnt on the projects homepage, so if you are new to NAnt I’d advise you to take a look at the project’s homepage here: http://nant.sourceforge.net/.

The problem

In some areas of software development, this is a problem of supporting different hardware setups, but in web development we (most often) only have to worry about different database connection strings, mail server setup, paths to e.g. upload folders, and similar configuration differences on different environments.

Several solutions to this problem have been suggested, but common for all solutions is a goal to automate this process of supporting multiple environments without having to manually figure out which configuration bits that needs to be flipped.

Furthermore, as developers we are used to working by contracts. At a very lowest level we have an unspoken contract with the compiler, making sure that we keep to the rules of our language of choice. Our types and methods too define contracts on what we are allowed to do. Webservices rely heavily on contracts, just as any services in the real world do. Surprisingly though, while our applications and websites more often than not rely on configuration files to keep them running, our configuration files are just flat files. In other words, there is no contract preventing us or at least warning us from making errors that in worst case scenarios could bring everything crashing down around our ears. Solving this part of the problem is hard. While you can build procedures to automatically check that everything looks nice, actually validating the data is a topic worthy of a book in itself.

Solution

Automatically building environment specific configurations is nothing new, in fact a tool is built right into Visual Studio 2010.

The Web.config transformation tool in Visual Studio allows you to:

• set attributes
• remove attributes
• delete nodes
• replace nodes
• insert nodes

in your Web.config file. This is great.. as long as all you require is the ability to modify your Web.config file from environment to environment but if either of the following statements are true:

• I keep certain configuration bits outside the Web.config file
• I’m not .NET web developer using Visual Studio

this solution is not for you. Not to mention, this does not ensure that aconfig file for a specific environment is not missing a vital property.

Our solution

While our work primarily involves ASP.NET web development, the projects we work on require a much high degree of configuration customization than the Web.config transformation tool described above facilitates.

Our goal was to create a configuration framework that would provide us with a high degree of customization and at the same time be statically compiled, preventing us from building and then deploying a bad environment configuration.

We ended up with a solution looking something like the figure below:

In the figure above, the boxes on the left (“Templates” and “Environment specific properties”) are especially interesting.

“Templates”, surprisingly, contains templates. For example, it might contain a Web.config template in which connection string values are not defined. It could also contain a license file template, in which the license key was not defined. Instead of defining the environment specific values, that is connection string and license key values, a uniquely named property is written. This property will then be substituted for an environment specific value by the configuration framework when the project is built.

At build time, we then invoke the configuration framework, which collects all the templates and attempts to populate them with properties from a specific environment configuration. Now, if a property is not found, the build will fail and warn us about the missing property. This is great, since we only have to maintain one configuration file (the template), but can still modify and build it across multiple environments and at the same time ensure that all configuration files contain all required properties.

The figure below illustrates this process:

Hopefully this has piqued your interest. If so, stay tuned for the next post in which we will go into the technical details of our solution and best of all, offer it to you free of charge.

Read the next post here: Targeting multiple environments and machines – part 2/2

Avisen har været på besøg hos Valtech og lavet et interview med de ansatte omkring demokratiseringsprocesserne  i Valtech.

Se interviewet her: