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

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:

WorldBlu er en global bevægelse for demokrati på arbejdspladsen, og organisationen har selv hæftet en undertitel på navnet: Freedom at work.

WorldBlu tilbyder en certificering, hvor virksomheder bliver bedømt på en række demokratiske parametre. 52 virksomheder er blevet certificeret i år – heriblandt danske Valtech.

I forlængelse af vores certificering, deltager vi på konferencen Worldblu Live 2011, der afholdes 19. – 20. maj i San Francisco. Følg med her på siden for opdateringer fra konferencen, samt på facebook og twitter.

Og du kan i følgende video høre Traci Fenton, founder af Worldblu, fortælle mere om, hvorfor hun startede organisationen og hvad organisatorisk demokrati og frihed på arbejdspladsen betyder.

Click here to view the embedded video.

Click here to view the embedded video.

Skriv dig op til at modtage vores eventkalender her på siden (øverst højre kolonne) og modtag invitationer til vores events og bliv opdateret på de seneste trends inden for digital marketing.

I morgen taler Valtech om hvorfor Morten Albæk kan have ret sin i kritik af reklamebureauerne og hvordan vi der arbejder med digitale marketingløsninger, bør indtage en mere dominerende rolle i fremtidens brede markedsføring. Det gælder både os der arbejder på de digitale bureauer og alle de marketingchefer og e-commerce managers, der dagligt arbejder med bruger-adfærd, salg og marketing ude i virksomhederne.

Det hele handler om hvorfor og hvordan virksomheder kan udvikle services, der understøtter eksisterende interesser og behov – om hvorfor reklamebudgettet skal bruges mere aktivt i udvikling af digitale services i stedet for at opfinde nye behov og såkaldte ”sjove” TV kampagner der skal få os til at grine – og intet andet.

Det handler om at vi som virksomheder skal lære vores kunder bedre at kende, i stedet for blot at tænke på one-time salgsknald og image. Kunderne er jo loyale nok – bare de bliver behandlet ordentligt.

Det er komplekst at behandle kunder ordentligt. Det skal gøres igennem personaliserede kanaler, såsom behavioral targeting, dialog og opdaterede CRM systemer.

Der er derfor ingen undskyldning mere – det hele skal samles i én central kundedatabase, der opsamler viden om kundens adfærd både i de enkelte sociale kanaler, i den virkelige mobile verden og på websitet.

Derfor kan vi som digital branche tilbyde en sammenhængende kundeoplevelse, både når det handler om indspark i forhold til købsadfærd og konkret i forhold til handel i den enkelte detailbutik.

Skriv dig op til at modtage vores eventkalender her på siden (øverst højre kolonne) og modtag video, billeder, præsentationer, m.m. fra dagen.

This year, I (Jonathan Astor) was there to savor the experience and lap up priceless knowledge on current and future trends. Over the course of the following weeks, I will share key trends and insights with you. Be prepared for a few surprises along the way, as our resident social business dynamo (kind of like that title) also managed to interview some industry legends and techies.

Key trends covered in future posts: augmented reality – gimmick or reality?location based services – will life become one big check in? The ’Thank You Economy’ and corporate humanization, gamification and Web3.0. I have also uploaded some pics from SXSW to Valtech on Flickr, if you fancy. Virtual gift possibly for the first person who can count correctly the QR codes in our photostream

//email jonathan.astor@valtech.dk with your answer.

http://www.flickr.com/photos/valtech/

SCNGR’S founder keynoted at this year’s SXSW Interactive festival in Austin, Texas attended by over 40,000 nerds, VC’s, Silicon Valley startups, digital media folk and Valtech Denmark’s own ninja Jonathan Astor all geeking out together on the very latest thinking on all things interactive. SCVNGR is a (LBS) like Foursquare/Gowalla but on steroids, not only can you check-in to venues but participants can also leave challenges behind for peers to complete and pick up points and badges. Seth demonstrated quite ably how check-ins at physical venues can generate commercial success however this is ameliorated once you add further challenges to the equation and that’s the whole point of SCVNGR, its more than just a check-in concept and there’s more to the game hence its stickier and then some. Others to have graced SXSW Interactive in years gone by have been the likes of Jobs, Gates, Zuckerberg, the Foursquare founders to name a few. SXSW is a big deal that’s what i’m trying to say.

I digress. As being social is such an inherent human behavioral pre-disposition, so is gaming . We’re born to be social, we’re also wired to game from birth. Seth proceeded to demonstrate that a game layer applied to education, customer acquisition, loyalty and even global warming will be instrumental in overcoming obstacles faced in attempts to make them more effective. Take schools, currently based on an antiquated grading score or a ‘broken game’, as he puts it, where you can lose too easily and based on a negative points system where you pass or fail breeding winners and losers – and that ain’t right. No child should be made to feel like a failure. Introduce a positive game layer, where you gain badges for achievement or an improved avatar as you proceed to the next level, breeds just winners as you can’t lose, its simply about the time it takes to get from one level to the next. This turns a negative game into a positive one and eradicates failure and furthermore may well engage kids to a higher degree by applying the cultural practices of their digital lives into the less engaging and more staid ‘classroom’ experience. School is a game just a poorly designed one. How many other institutions or corporations are in the ‘broken game’ category that this applies to?

The game layer can also be applied to customer acquisition as a rewards based system and level progression dynamic can keep customers’ loyal and returning to a brand’s digital/physical spaces time and time again, similar to Amex’s card system where you can graduate from colour to colour or the airmiles system. The key drivers to an effective game are ‘communal gameplay’, that’s the social aspect – ‘a free offer’, that’s the reward and a ‘countdown’, so offers are time limited to encourage immediate uptake. These are the exact ‘game’ drivers to $15 billion dollar valued Groupon’s crowdsourced platform’s success, as dissected by Seth. Other mechanics would be providing stakeholders with status. Check out Microsoft’s Most Valued Partner Programme that rewards their most engaged advocates with a title or exclusive badge or Starbuck’s that automatically enters its Foursquare mayors into the ‘Starbucks Society’. Not only does this drive loyalty but also positive word of mouth – who isn’t going to tweet or post about this?

Our 21 year old check-in champ would have you believe that the game layer can also solve global warming, he gives no evidence of this however it reminded me of  a story I heard a while back about an electricity supplier who used a game of sorts to help reduce its customers consumption. Customers were advised on their bill not only of their total consumption for the period, but also that of their neighbours. They were presented with a leaderboard with those at the top being the ones who consumed the least power. On receiving their next bill those performing poorly initially now started turning off their lights as they should do,  and consumed less power . However initial leaders started performing worse and dropped down the leaderboard. The lesson here is that a gaming mechanic works but needs to be complemented by a rewards system, or better still immediate gratification in order to incentivize folks to keep performing or transacting for a sustained period of time, not just once or twice. This is an awesome example of the social and gaming layer working in synch and that’s what the digital savant is telling us. The social being connecting people together and driving community around electricity usage levels, the leaderboard and rewards system being the game layer. One without the other may weaken the ability to influence at the most critical points of the engagement funnel. Bring on the game layer and things get done, not only passed around, posted, tweeted, retweeted, that in their own rights essential, however in isolation less potent.

Seth got my mind wondering into its creative faculty. Imagine if you apply this logic to pharma or healthcare, one of many of  Valtech’s specialisms. A newly diagnosed diabetes patient starts treatment paying 100% of their medical care themselves. However as he/she starts building points and badges checking in to gyms, eating well, injecting and testing properly, their costs spiral downwards, potentially to zero. Therefore you get rewarded for taking care of yourself and penalized for not following doctors orders. Somebody stop me please.. how about other client sectors?. I’m sold it makes sense. Life could well prove to be one big check-in .Wanna play?