Atom, Snippets, Tabs and CSON parsing

This morning on the train down from Manchester to Bristol I fired up the Atom editor and noticed that when trying to load a snippets file from my ui5-snippets package, I got an error:

Screen Shot 2015-01-19 at 08.18.19

Between Stafford and Wolverhampton I hacked around with the source, particularly the html.cson file that contained a number of UI5 snippets for HTML files. From where was this error message emanating, and why now?

Well, it seems that a few days ago, in release 0.171.0, Atom had moved from parsing CoffeeScript Object Notation (CSON) with cson, to parsing with cson-safe. CSON is the format in which snippets can be written. Moving to cson-safe meant that the parser was rather stricter and was the source of the “Syntax error on line 4, column 11: Unexpected token” error.

By the time we’d got to Birmingham, I’d figured out what it was: tabs. In wanting to move in the direction of the UI5 coding standards, I’d started moved to tabs for indentation within the UI5 snippets, as you can see in this openui5 starter snippet. While the original cson parser used by Atom was fine with real tabs in the snippet source file, cson-safe didn’t like them.

Switching the tabs to literal “\t” tab representations (i.e. backslash then ‘t’) solved the issue.



Fiori App Data into a Spreadsheet? Challenge Accepted!

In October last year, following the original meta SAP Fiori App ;-), SAP announced their own long-awaited SAP Fiori Apps Reference Apps Library. At the time, Brenton and I chatted about it in “SAP Fiori & UI5 Chat, 17 Oct 2014“.

Today there was a comment in the announcement post, asking whether there was “any way this information can be supported via a downloaded (into Excel perhaps)?  It would make sorting and filtering much easier“.

Seeing as one of the technical guidelines for Fiori apps is the use of an OData service to supply the domain data, and I had a bit of time over lunch, the well known phrase “Challenge Accepted!” floated into my consciousness.

With the power of OData, JSON, Google Apps Script and the generally wonderful cloud productivity platform that is Google Apps, I set to work, and within a short amount of time, the challenge was completed.

Here’s a video with all the details. The spreadsheet is here,

Share and enjoy!


Running: 2014 in review, and some Clojure

I enjoyed running in 2014 and logged each one via Endomondo. This post is a random collection of thoughts about the running, the data and some simple analysis, in Clojure.


Garmin Forerunner 110

Garmin Forerunner 110

I’ve been using a Garmin Forerunner 110 watch which has been very good, on the whole, although the USB cable and connectivity left something to be desired.

I bought my wife Michelle a TomTom Runner Cardio for her birthday back in August, and have been intrigued by it ever since. And she bought me one for Christmas, so I’m trying that out for 2015. I went out on my first run of this year with it just this morning, in fact.

Run data

But back to 2014. I completed 101 runs (1,281.22km) and they’re all logged in Endomondo. I don’t have the premium subscription, just the basic, but the features are pretty good. There’s an option to upload from the Garmin watch, via a browser plugin which (on this OSX machine) has become pretty flakey recently and now only works in Safari, but once uploaded, the stats for each run are shown rather nicely:

A run on Endomondo

A run on Endomondo

Endomondo also offers simple statistics and charts, and a tabular overview of the runs, that looks like this:

Tabular view of runs in Endomondo

Tabular view of runs in Endomondo

One thing that bothered me, at least with the free service, is that there was no option to download this data. So I paged through the tabular data, and copy/pasted the information into a Google Sheet, my favourite gathering-and-stepping-off point for a lot of my data munging.

Running history in a Google Sheet

Running history in a Google Sheet

If nothing else, as long as the data is largely two dimensional, I’ve found it’s a good way to visually inspect the data at 10000 feet. It also affords the opportunity for some charting action, so I had a look at my pace over the year, to see how it had improved. This is the result:

Pace improvement in 2014

Pace improvement in 2014

The three peaks in Feb, Jun and Sep are a couple of initial runs I did with Michelle plus her first 8km in London (now she’s in double km figures and has a decent pace, I’m very proud of her).

Some Analysis in Clojure

I could have gone further with the analysis in the spreadsheet itself, but I’m also just starting to try and teach myself Clojure, and thought this would be a nice little opportunity for a bit of data retrieval and analysis.

Exposing the data

Start of the JSON representation of the run data

Start of the JSON representation of the run data

Of course, the first thing to do was to make the data in the Google Sheet available, which I did with my trusty SheetAsJSON mechanism. It returned a nice JSON structure that contained all the data that I needed.

So now I had something that I could get Clojure to retrieve. Here follows some of what I did.

Creating the project

I’m using Leiningen, which is amazing in a combined couple of ways: it Just Works(tm), and it uses Maven.  My only previous experience of Maven had me concluding that Maven was an absolute nightmare, but Leiningen has completely changed my mind. Although I don’t actually have to think about Maven at all, Leiningen does it all for me, and my hair is not on fire (for those of you wondering, Leiningen’s tagline is “for automating Clojure projects without setting your hair on fire”, which I like).

So I used Leiningen to create a new application project:

lein new app running-stats

and used my joint-favourite editor (Vim, obviously, along with Atom), with some super Clojure-related plugins such as vim-fireplace, to edit the core.clj file. (more on my Vim plugins another time).

Here’s a short exerpt from what I wrote:

Screen Shot 2015-01-03 at 12.51.47

Let’s look at this code step by step.

Library use

I’m using Clojure’s data.json library (line 2) to be able to parse the JSON that my SheetAsJSON mechanism is exposing. I’m also using the clj-http HTTP client library (line 3) to make the GET request. Finally I’m using the clojure.walk library (line 4) for a really useful function later on.

I decided to churn through step by step, which is why you’re seeing this code in four chunks, each time using the def special form to create a var in the current namespace.

Creating stats

There’s stats (line 6), which has the value of the parsed JSON from the body of the response to the HTTP GET request. To unravel lines 6-9 we have to read from the inside outwards.

First, there’s the call to client/get in line 9 (the clj-http library is aliased as client in line 3). This makes the HTTP GET request and the result is a Persistent Array Map that looks something like this:

running-stats.core=> (client/get "")
{:cookies {"NID" {:discard false, :domain "", :expires #inst "2015-07-05T12:23:49.000-00:00", :path "/", :secure false, :value "67=EUPTfvAv3U5Vofm1F3Fb_D9OjmwYS1yC3Ju-uvgostmqzKSNLHKHiHGMc-cwFBAES0R3qcLFQW7W75x6sZjSzein3H7Trxeg6Bk0wOJ0q-AaYXA0RxYw0-uEhR5ogaXg", :version 0}}, :orig-content-encoding nil, :trace-redirects ["" "
5, :status 200, :headers {"Server" "GSE", "Content-Type" "application/json; charset=utf-8", "Access-Control-Allow-Origin" "*", "X-Content-Type-Options" "nosniff", "X-Frame-Options" "SAMEORIGIN", "Connection" "close", "Pragma" "no-cache", "Alternate-Protocol" "443:quic,p=0.02", "Expires" "Fri, 01 Jan 1990 00:00:00 GMT", "P3P" "CP=\"This is not a P3P policy! See for more info.\"", "Date" "Sat, 03 Jan 2015 12:25:02 GMT", "X-XSS-Protection" "1; mode=block", "Cache-Control" "no-cache, no-store, max-age=0, must-revalidate"}, :body "{\"Year-2014\":[{\"Date\":\"2014-01-02T00:00:00.000Z\",\"Description\":\"First run of 2014\",\"Distance\":\"13.50 km\",\"Time\":\"1h:13m:51s\",\"Avg_Speed\":\"11.0 km/h\",\"Avg_Pace\":\"5:28 min/km\",\"Avg_HR\":168,\"Distance_Value\":13.5,\"Pace_Value\":\"1899-12-30T05:28:00.000Z\",\"Pace_Val_Mins\":5,\"Pace_Val_Secs\":28,\"Pace_In_Secs\":328,\"Month_of_Run\":1},{\"Date\":\"2014-01-05T00:00:00.000Z\",\"Description\":\"Wet and windy Copster Hill.\",\"Distance\":\"14.05 km\",\"Time\":\"1h:16m:31s\",\"Avg_Speed\":\"11.0 km/h\",\"Avg_Pace\":\"5:27 min/km\",\"Avg_HR\":169,\"Distance_Value\":14.05,\"Pace_Value\":\"1899-12-30T05:27:00.000Z\",\"Pace_Val_Mins\":5,\"Pace_Val_Secs\":27,\"Pace_In_Secs\":327,\"Month_of_Run\":1},{\"Date\":\"2014-01-08T00:00:00.000Z\",\"Description\":\"Brookdal [...]

Quite a bit of a result. Looking at the keys of the map, we see the following, which should be somewhat familiar to anyone who has made HTTP calls:

running-stats.core=> (keys (client/get ""))
(:cookies :orig-content-encoding :trace-redirects :request-time :status :headers :body)

There we can see the :body keyword, which we use on line 8 as an accessor in this collection. With this, we get the raw body, a string, representing the JSON:

running-stats.core=> (:body (client/get ""))
"{\"Year-2014\":[{\"Date\":\"2014-01-02T00:00:00.000Z\",\"Description\":\"First run of 2014\",\"Distance\":\"13.50 km\",\"Time\":\"1h:13m:51s\",\"Avg_Speed\":\"11.0 km/h\",\"Avg_Pace\":\"5:28 min/km\",\"Avg_HR\":168,\"Distance_Value\":13.5,\"Pace_Value\":\"1899-12-30T05:28:00.000Z\",\"Pace_Val_Mins\":5,\"Pace_Val_Secs\":28,\"Pace_In_Secs\":328,\"Month_of_Run\":1},{\"Dat [...]

Now we need to parse this JSON with the data.json library, which we do in line 7. This gives us something like this:

running-stats.core=> (json/read-str (:body (client/get "")))
{"Year-2014" [{"Pace_Val_Secs" 28, "Distance_Value" 13.5, "Date" "2014-01-02T00:00:00.000Z", "Month_of_Run" 1, "Description" "First run of 2014", "Distance" "13.50 km", "Avg_Speed" "11.0 km/h", "Pace_Val_Mins" 5, "Pace_Value" "1899-12-30T05:28:00.000Z", "Avg_Pace" "5:28 min/km", "Time" "1h:13m:51s", "Pace_In_Secs" 328, "Avg_HR" 168} {"Pace_Val_Secs" 27, "Distance_Value" 14.05, "Date" "2014-01-05T00:00:00.000Z", "Month_of_Run" 1, "Description" "Wet and windy Cop [...]

which is eminently more useable as it’s another map.

Although it’s a map, the keys are strings which aren’t ideal if we want to take advantage of some Clojure idioms. I may be wrong here, but I found that converting the keys into keywords made things simpler and felt more natural, as you’ll see shortly.

The Year-2014 data set

Lines 11-13 is where we create the Year-2014 var, representing the data set in the main spreadsheet tab.

Looking up the “Year-2014″ key in the stats (line 13) gave me a vector, signified by the opening square bracket:

running-stats.core=> (stats "Year-2014")
[{"Pace_Val_Secs" 28, "Distance_Value" 13.5, "Date" "2014-01-02T00:00:00.000Z", "Month_of_Run" 1, "Description" "First run of 2014", "Distance" "13.50 km", "Avg_Speed" "11.0 km/h", "Pace_Val_Mins" 5, "Pace_Value" "1899-12-30T05:28:00.000Z", "Avg_Pace" "5:28 min/km", "Time" "1h:13m:51s", "Pace_In_Secs" 328, "Avg_HR" 168} {"Pace_Val_Secs" 27, "Distance_Value" 14.05, "Date" "2014-01-05T00:00:00.000Z", "Month_of_Run" 1, "Description" "Wet and windy Copster Hill.",

The vector contained maps, one for each run. Each map had strings as keys, so in line 12 I used the keywordize-keys function, from clojure.walk, to transform the strings to keywords. Here’s an example, calling the function on the map representing the first run in the vector:

running-stats.core=> (keywordize-keys (first (stats "Year-2014")))
{:Pace_Value "1899-12-30T05:28:00.000Z", :Month_of_Run 1, :Distance_Value 13.5, :Distance "13.50 km", :Avg_HR 168, :Avg_Pace "5:28 min/km", :Pace_Val_Mins 5, :Pace_Val_Secs 28, :Date "2014-01-02T00:00:00.000Z", :Description "First run of 2014", :Time "1h:13m:51s", :Avg_Speed "11.0 km/h", :Pace_In_Secs 328}

I assigned the resulting value of this call to a new var Year-2014.

Getting the HR values

The Garmin Forerunner 110 measures heart rate (HR) via a chest strap, and an average-HR detail is available for each run:

running-stats.core=> (:Avg_HR (first Year-2014))

There were a few runs where I didn’t wear the chest strap, so the value for this detail on those runs was a dash, rather than a number, in the running statistics on the Endomondo website, which found its way into the spreadsheet and the JSON.

running-stats.core=> (count (filter (comp not number?) (map :Avg_HR Year-2014)))

Yes, six runs altogether without an average HR value. So to get the real average HR values, I just needed the ones that were numbers. I did this on lines 15-17.

By the way, composing with the comp function sort of makes me go “wow”, because I figure this is revealing a bit of the simplicity, depth and philosophy that lies beneath the scratch mark I’ve just made in the surface of functional programming in general and Clojure in particular.

Average HR

I took the average of the HR values in line 21. This actually returned a Ratio type:

running-stats.core=> (/ (reduce + HR-values) (count HR-values))
running-stats.core=> (type (/ (reduce + HR-values) (count HR-values)))

This was interesting in itself, but I wanted a value that told me something, so I called the float function in line 20:

running-stats.core=> (float (/ (reduce + HR-values) (count HR-values)))

(Yes, I know taking the average of averages is not a great thing to do, but at this stage I’m more interested in my Clojure learning than my running HR in 2014).

And more

I did continue with my analysis in Clojure, but this post is already long enough, so I’ll leave it there for now. If you got this far, thanks for reading! I hope to teach myself more Clojure; there are some great resources online, and the community is second to none.

If you’re thinking of taking the plunge, I’d recommend it! I’ll leave you with a quote from David Nolen at the end of his talk “Jelly Stains. Thoughts on JavaScript, Lisp and Play” at JSConf 2012:

“[Dan Friedman and William Byrd] got me realising there’s a lot more left to play with in Computer Science”.

As I embark upon my journey in this direction, I realise that’s a very true statement. It’s like learning programming all over again, in a good way!



DNA is still in our DNA

Via a tweet that was retweeted by Ben Nuttall, I came across a recent article in the Independent “Microsoft to replace Internet Explorer with new, streamlined browser“. The article has some classic sentences that made me groan with displeasure, not least the lead:

“Codenamed Spartan, the new app will look much more like competitors Chrome and Firefox”

which completely misses the major point in that it’s not how IE *looks*, it’s how it *behaves*.

Anyway, the sentence that most caught my eye was this one:

In the past the company has considered changing the name to separate the current browser from “negative perceptions that no long reflect reality”

This very much reminds me of a passage from Douglas Adams’s Hitch Hiker’s Guide To The Galaxy, specifically from Episode 11:

The problem of the five hundred and seventy-eight thousand million Lintilla clones is very simple to explain, rather harder to solve. Cloning machines have, of course, been around for a long time and have proved very useful in reproducing particularly talented or attractive – in response to pressure from the Sirius Cybernetics marketing lobby – particularly gullible people and this was all very fine and splendid and only occasionally terribly confusing. And then one particular cloning machine got badly out of sync with itself. Asked to produce six copies of a wonderfully talented and attractive girl called “Lintilla” for a Bratis-Vogen escort agency, whilst another machine was busy creating five-hundred lonely business executives in order to keep the laws of supply and demand operating profitably, the machine went to work. Unfortunately, it malfunctioned in such a way that it got halfway through creating each new Lintilla before the previous one was actually completed. Which meant, quite simply, that it was impossible ever to turn it off – without committing murder. This problem taxed the minds, first of the cloning engineers, then of the priests, then of the letters page of ’The Sidereal Record Straightener’, and finally of the lawyers, who experimented vainly with ways of redefining murder, re-evaluating it, and in the end, even respelling it, in the hope that no one would notice.



The Inaugural SAP Architect & Developer Summit

Update: This has also been published on the Bluefin Solutions website

I was honoured to have been invited to speak at the inaugural SAP Architect & Developer Summit which happened last week (20-21 Nov 2014) in Sydney. It was a fantastic event, mainly due to the people and the content, but also because it hit a sweet spot between different types of SAP developer events.

The summit was the first of its kind to be organised by SAP, and judging from the feedback from the attendees there and then, combined with my own experience, it was a huge success. It was held over a two day period in the centre of a hotbed of SAP architect and developer talent, with folks converging on the wonderful Australian Technology Park in Sydney from all over the region, plus various additions from the UK, USA and elsewhere.

The Australian Technology Park was almost the perfect setting, being based on a centre of technology (heavy transport and industry) from the last millenium, a centre that proudly displayed historical, and some still-working physical artifacts, reminding me a lot of the Museum of Science & Industry back home in Manchester.

The Summit

Falling directly after SAP TechEd Berlin, firmly within the SAP tech conference season, the summit attracted over 300 attendees. There were a number of reasons for this being a great event to attend – the style was a sweet-spot between different sized events, it was priced well, and the content was just right.

Sweet Spot

There’s the daddy of all SAP conferences, SAP TechEd && d-code, and then at the other end of the scale there are grass roots community-organised types such as CodeJams and InsideTracks. While the former extends, with the InnoJam pre-event, to more or less a week, and the latter often being single-day affairs, this summit hit the sweet spot in between, finding a great balance between time and content.

Price Point

This was one of those unusual events where the travel and accommodation costs, even for those relatively local, were more than the event itself. (Because I was speaking, SAP covered my costs – thank you!). This is significant; a price point of AUD 695.00 (around GBP 385.00) combined with the agenda means that it was hard to resist.

People & Content

The two most important ingredients of course for any event are the people and the content, often going together. Here are just a few of the hands-on workshop items from the agenda:

  • Developing SAP HANA Native Applications with SAP HANA Cloud Platform (Thomas Jung)
  • Designing SAP Fiori Custom Applications (Kynan Jones & John Patterson)
  • SQLScript – Push Code Down into SAP HANA to Achieve Maximum Performance (Rich Heilmann)
  • Advanced OData Service Development with SAP Gateway (Mustafa Saglam)
  • Build SAP HANA Cloud Applications which Integrate with On-Premise Systems (Chris Paine)

With those sessions typical of the quality and content, given by those people, you know it’s going to turn out well.

Just as significant as the agenda were the conversations to be had with the amazing folk that were there too. Trying to name them all would be an exercise in futility; suffice it to say that the large majority of what I’m going to call the “ANZ SAP Mob” (in reference to the “Dutch SAP Mafia”) were there, which for me was reason enough to attend. To be able to learn from conversations with these people was priceless.

My Contribution

I was lucky enough to be able to contribute in three ways to this summit.


I gave a keynote at the end of Day 1 (called a “locknote” – who knew?) entitled “Fiori and UI5 Software Logistics, or: Are We in the Future Yet?“.

My aim was to convey the idea that in the SAP development world, we’ve been heretofore shielded from and largely unaware of one of the most important parts of software development – the artifacts.

You could perhaps think of artifacts as the tangible results of our mental machinations, a developer currency that we grow, discuss, exchange and share. And with the advent of Fiori and UI5 development, we should think explicitly about how we should nurture these artifacts to be the best we can make them, and in doing that, embrace tools available outside the traditional SAP developer ecosphere. Tools such as linters, editors, workflow mechanisms and source code control systems. In particular, I focused on git and Github Workflow.


On Day 2 I held a 2 hour hands-on workshop entitled “Learn to Drive Fiori Applications from Underneath and Level Up!“.

Workshop booklet screenshot

In this workshop I took the attendees (the workshop was fully booked!) through a Fiori application, from underneath, discovering it, controlling it, driving it and modifying it via the Chrome Developer Tools. There was a lot of content to get through but we managed it, not least due to the fact that everyone got on board with the approach and really did a great job in collaborating and keeping up with me. Thanks folks!

When I was preparing the workshop booklet, it took on a life of its own, so much so that it turned into a standalone 48-page mini-publication so that anyone who had it could follow through everything I wanted to teach, even after the workshop. And I’m making that workshop booklet available to everyone so that they can all benefit:

Workshop Booklet: Learn to Drive Fiori Applications from Underneath and Level Up!

If you would like to leave any feedback please go ahead and do that at the end of this post.

Executive Lunch

On Day 1 there was an Executive Lunch event with folks from all around the Australia and NZ region. I spoke on the new development paradigm that Fiori and UI5 has ushered into the SAP developer world, and gave an impromptu demonstration on UI5 development, building a simple app as they ate their lunch :-)

The Future

I hear that SAP ANZ are planning to run this event again next year, which is great. The aim is to attract more attendees, which is also great. But there’s also a balance to be maintained; the synergy, the timing of two full days, the ability to talk to everyone, was, in my opinion, just right.

I’m really hoping that this event has a future, stays roughly true to this inaugural incarnation, and spreads to other areas around the globe. If one came to Europe, I’d sign up immediately and encourage my fellow SAP hackers to do the same.

Well done to all the team for organising this, and thanks to all the superheroes that attended and shared knowledge and experience. We are architects and developers. Learning from one another and sharing with one another is what we do.


Creation & Reload of UI5 UIs in the Chrome Developer Console

At the inaugural SAP Architect & Developer Summit last week, one of the things that I did was prepare and deliver a 2 hour hands-on workshop: “Learn To Drive Fiori Applications From Underneath And Level Up!“. This was a fun and successful workshop which focused on working within, and using the tools of, the powerful Chrome Developer Console. It triggered great conversations afterwards with some folks, including fellow SAP Mentor Matt Harding, who also tweeted:

Screen Shot 2014-11-24 at 14.58.39

One of the strands of the conversation with Matt, Nigel James & others was regarding the potential transient nature of the definition of views, or other smaller UI elements, created while working within the console. In the console you can quite easily build views in JavaScript (as the console is a JavaScript console!). Building machine readable, declarative views such as those based on XML or JSON is a little bit more cumbersome.

However, with a great feature of the UI5 Support Tool – Export to XML – we can indeed have our UI declared for us in XML, which is rather useful! Not only that, but we can then iterate by loading that generated XML back into Chrome.

While at SYD airport just now, waiting for my flight back home, I recorded a quick screencast to illustrate this. It shows the creation of a quick UI, using the manual console techniques we learned in my workshop. Then, the UI is exported as XML, which the Support Tool duly does for us, inside an XML View container. That exported XML View is then reloaded, and we can see of course that it is faithful to what was originally created.

Share & enjoy!

This Week in Fiori (2014-43)

Hello everybody,

Brenton here in for DJ this week. For those of you who don’t know me, I work in the Fiori and User experience space with DJ and I am a fellow SAPUI5/OpenUI5 advocate for a long time now. I focus more on the mobility side of things more than anything else but for me it’s all about bringing amazing solutions to end users and having a bit of fun while doing it :-)

So this week of course was the beginning of what I call TechEd season or now I suppose we have to call it d-code season. Last week saw SAP TechEd and d-code take place in the wonderful Venetian resort in Las Vegas. Now that I am starting to get over my jet lag, DJ asked me to jot down a few of the highlights for this edition of “This Week in Fiori”.

SAP Executive Keynote from SAP TechEd & D-code by Steve Lucas
The first mention has to go, of course, to the keynote with Steve Lucas. With a relaxed and developer focused atmosphere it was an incredibly enjoyable 75 minutes covering some of the amazing things that people are doing with SAP software. The reason it gets a special mention here is because it was (for me anyway) the first time I saw SAP Fiori on a watch. Steve introduces a real-time Fiori application on the HANA cloud platform which was integrated with and primarily used on Samsung’s latest smart watches. The demo is at about 59+ minutes for anybody interested. In fact, the entire keynote is well worth the time as it really brought to life some of SAP’s new technologies.

SAP Fiori Launchpad Overview by Aviad Rivlin
Aviad does it again with this excellent overview of the SAP Fiori Launchpad in this voice-over session. Talking us through the Launchpad itself, it’s capabilities as well as an overview of how the launchpad could work in a Hybrid scenario where some functionality is based on-premise and some based in the cloud. Well worth a watch for anybody interested or working with the Launchpad.

Unified Inbox with SAP Fiori by Ramana Mohanbabu
This was quite an interesting session I enjoyed covering the connection of the SAP Fiori Unified inbox to multiple systems to give an end user access to all of their SBWP items in a much more usable way.

Swell Analytics by Clint Vosloo and Chris Rae
Although competing directly with myself and John Appleby during this years DemoJam I am always more than happy to give credit where it is most definitely due and these guys deserve it! They created an amazing application using OpenUI5 to identify, predict and rate the quality of swells for surfers (yes I said surfers!). Well worth a watch and shows off the awesome stuff you can build with OpenUI5.

These are just 4 of the very many Fiori and OpenUI5 related sessions from Las Vegas that caught my eye. If I was to mention all of the sessions, you would get bored far quicker than I can type so I won’t even try. But please do check out the rest of the sessions covering all SAP’s new offerings from the HANA Cloud Platform (HCP), SAP Mobile Secure right through to the easy way developers can try all this out for themselves at

So all that is left for me to do is thank DJ for allowing me to post on some of my experiences from Las Vegas. TWIF is an excellent series and one I love reading each week!

Comments most welcome as always!


This Week in Fiori (2014-42)

Screen Shot 2014-10-19 at 21.27.11Well hello again, I’m back. I couldn’t miss the most significant week number, now, could I? :-) And next week I have something special for you — the TWIF episode will be written by a guest author. Really excited about that! If you’re interested in becoming a guest writer for this series, get in touch! Ok, let’s get to it.

SAP Portal and SAP Fiori – Common Architecture by Aviad Rivlin
Aviad has been at it again producing great content and bringing more clarity to this important subject. Although only a short post, it’s worth mentioning here, because it helps crystallise SAP’s intentions in this space (readers of this TWIF series have seen many mentions of this subject in the past) and also because it points to a whitepaper “SAP Enterprise Portal and SAP Fiori – Common Architecture Recommendations” which is worth a read.

What’s New in SAP Fiori Launchpad by SAP
For the UI Add-On for NetWeaver, otherwise known as UI2, version 1.0 SPS 10 is now available. This is a layer of software that provides a lot of the Fiori services and infrastructure (yes, there’s more to Fiori than just UX, you know ;-) including the UI5 runtime, the personalisation services and the Launchpad. While the individual Fiori apps are of course the main event, without this layer, without the Launchpad, the experience would be lacking something.

This What’s New document, in the UI2 section of, gives us a good overview on what have been the important areas of focus for SAP in the recent period. Notably, these areas are for Portal integration (the headerless mode) and performance. With performance, there have been various improvements, from moving the storage of personalisation information from an XML document to database tables (who thought using XML documents for storage of large amounts of data was a good idea?) to cacheing of target mappings in the browser. Nice!

SAP Fiori, Demo Cloud Edition by SAP
Well, it was a long time coming, and it’s still not ideal, but it’s THERE! An online, available, demo version of SAP Fiori. For folks to get a better feel for the Launchpad, for some of the apps, and to experience the UX first hand. Not only will this be great for all of that, but for those implementing their own Fiori apps, it will also serve as useful and hopefully always-available reference designs, alongside the SAP Fiori Design Guidelines I wrote about in TWIF episode 2014-28.

Why not ideal? Well, it only contains a very small number of apps from the 300+ available, and the sample data is a little flat. Here are the apps available:

    • Approve Timesheets
    • Approve Leave Requests
    • My Benefits
    • My Leave Requests
    • My Paystubs
    • My Timesheet
  • ERP SD (Logistics)
    • Change Sales Orders
    • Check Price and Availability
    • Change Sales Orders
    • Track Sales Orders
  • ERP Accounting
    • My Spend
    • Customer Invoices
  • ERP Logistics (MM)
    • Approve Purchase Contracts
    • Approve Purchase Orders
    • Approve Requisitions
    • Order From Requisitions

It’s early days for this demo, and I’m hoping to see a lot wider variety of apps available, along with more meaningful sample business data, in the next iteration. But until then, so far so good!

SAP Fiori & UI5 Chat, Fri 17 Oct 2014 by Brenton O’Callaghan and me
Earlier this year, Brenton and I ran a webinar “Understanding SAP Fiori Webinar” which was well received. I wrote it up in a post on SCN “The Director’s Cut” and also on Bluefin’s website “Webinar & More: Understanding SAP Fiori“, and in fact we’ll be running another SAP Fiori related webinar in December, watch this space!

Last Friday Brenton and I decided to sit down and shoot the breeze again on the subject of Fiori, this time looking at an SAP Fiori app that allows you to explore what Fiori apps are available. We looked at it from above, and from below, and had a great time doing so. It’s 30 mins long, so grab a cup of tea and a digestive biscuit and have a look: “SAP Fiori & UI5 Chat, Fri 17 Oct 2014

Until next time, share & enjoy!

Speaking at the SAP Architect & Developer Summit

Next month, in Sydney, the inaugural SAP Architect & Developer Summit is taking place, on the 20th and 21st of November. This is quite an exciting direction for an SAP event; yes, we have SAP TechEd && d-code (almost upon us) which caters for the developers and architects among us, but this short summit-style conference looks to be spot on in terms of content for the “non-suits”.

The agenda is packed with sessions I’m really looking forward to attending, and a huge list of amazing folks from the SAP world are there – many of them presenting. Check out the full agenda, available from this page to see what I mean.

I’m rather honoured to have been invited, and have a couple of speaking slots. I’ve added my sessions to the Lanyrd page for the conference, so the links below will take you to the slots there:

On day 1, I’m giving the Locknote Address, which is at the end of the day’s sessions and just before the cocktails, so I’d better keep it short and to the point! — Fiori & UI5 Software Logistics, or: Are We In The Future Yet?

On day 2, I’m running a 2 hour hands-on workshop “Learn to Drive Fiori Apps from Underneath and Level Up!“. This should be a lot of fun, and revolves around mastering the perfect storm of Chrome’s Developer Tools and the UI5 toolkit and support mechanisms.

As well as the summit’s website itself, you can read more about the event on Thomas Jung’s post on SCN: “Coming Down Under – see you at SAP Architect and Developer Summit in Sydney“.

I’m really excited to be attending, not least because I’m finally going to meet some of my heroes from the Australia & NZ SAP developer world. Sydney here I come!


This Week in Fiori (2014-40)

Screen Shot 2014-10-07 at 07.33.51Another week, another set of Fiori links. Let’s get to it!

Fiori App Reference Library app, via Luis Felipe Lanz
Well it was bound to happen, and I’m celebrating that. Luis tweeted a link to a lovely Fiori app, the Fiori App Reference Library, which contains details on the 300+ Fiori apps so far. Of course, the original meta Fiori app, the SAP Fiori App Analysis application (which I mentioned in TWIF 2014-31) is still going strong – find out more about this in this 5 min video “The SAP Fiori App Analysis application“.

But what about this new app from SAP (rather than from me)? Well, there are a couple of parts of the URL ( that suggest to me that it’s possibly temporary, or still in development (there are some active debugger statements in there too), but apart from that, it’s a fine example of a classic Fiori app and uses a 1.24 runtime of UI5. I’m tempted to dig in right now and start exploring how it’s put together, but I’ll leave that for another time. I’ll just point out that the data it uses is from a proper OData service which is in itself more useful than you might think – an official machine-readable detailed list of Fiori apps from SAP. Let a thousand consumer apps bloom!

SAP CodeJam on RDE at Ciber NL organised by Wim Snoep
SAP River RDE, or to give it its new name SAP Web IDE (hopefully it won’t change again :-) is an important topic to understand in the world of Fiori. It’s what many developers (although not all) will be using to manage Fiori apps from a creation and extension point of view. RDE has been a long time in gestation but today’s incarnation is very accomplished and those looking to understand what SAP’s approach to software management in the Fiori age is, need to spend some time investigating this.

One of the “Dutch SAP Mafia” members Wim organised an SAP CodeJam on RDE which looked to be a great success. The developer ecosystem is not just about the languages (say, JavaScript) and frameworks* (UI5) but also about the tools and environments within which one works. So this CodeJam was ideally suited to learning more about SAP’s environment. The day saw developers build Fiori applications in RDE, and I was happy to see that our TechEd hands-on session content CD168 Building SAP Fiori-like UIs with SAPUI5 — which was created for last year’s SAP TechEd events but has seen action ever since — was put to good use for this event too.

*actually one should refer to UI5 as a toolkit rather than a framework, for reasons too long and detailed to go into here :-)

Introduction to SAP Fiori UX by SAP 
I’ve written about this course from Open SAP before, most recently in the previous TWIF episode TWIF 2014-39. Well, I thought I’d give a quick update on my perspective … to say that I’ve abandoned the course. Fiori is a huge topic, and one can’t expect a single course to cover everything. But I did expect some UX content, as it’s an incredibly important aspect of the Fiori experience. Unfortunately I didn’t find any, and I noted that I wasn’t alone in this regard either.

With the combination of this issue and the as yet unresolved issues from Week 2, I decided that give up on the course and I’d devote the time I’d allocated for study to other more UX/UI related matters, in particular by studying further the SAP Fiori Design Guidelines that I wrote about in TWIF 2014-28 along with details of the latest responsive controls in the UI5 toolkit. Whether you’re following the Open SAP course or not, I’d encourage you to do the same, too.

I must say that I’ve not given up on Open SAP as a whole – in fact I’m eagerly awaiting the next Fiori related course … now that Fiori installation and configuration is out of the way with this first course, it could be full steam ahead for the UX part!

Update 20 Oct 2014: Since this post, there has been some discussion internally, on various email threads and also publically here and on Twitter. And today SAP posted “Help Shape the Next SAP Fiori Course” which acknowledges the issues with the lack of UX content and solicits input to determine the content for the next course. Well done Open SAP! This is a conversation in action. I’d encourage you to go over to the survey and add your thoughts.

Until next time, share & enjoy!