Skip to Content
Event Information

Hands-on SAP dev with qmacro – new live stream series

Starting mid January 2019, I’ll be live streaming weekly, on SAP development topics. The show is called “Hands-on SAP dev with qmacro” and will be broadcast on my Twitch channel on Fridays. This post tells you what else you might need to know. 

If you’re looking for information on the upcoming episode, go straight to the series page on Twitch, or jump down to the Upcoming Episode section below.

If you’re looking for the recordings of the live streams, jump down to the Catch the replays section below.

This post has multiple sections – here are quick links to them all: Background | Live streaming | Plans for the first episode | The schedule | How to watch | Catch the replays | Plans | Feedback | Wrapping up | Upcoming episode | Updates.

This post is also available via the short link http://bit.ly/handsonsapdev.


Background

One subject I’ve been thinking about for a while, especially in the context of my Monday morning thoughts series last year (in particular the learning continuum, growth is upwards and learning media and mechanisms posts) is how I take on new information.

One of the ways is to watch videos, and for me that is a medium that is easy and enjoyable to consume.

A wonderful bonus for me is the side effect of getting inside the heads of developers, learning, on a high level, how they operate, and noticing, on a low level, how they work on a day to day basis. On many occasions, the things I’ve learned have been serendipitous and only partially connected to the subject at hand. How a developer goes about editing, what tools they use, and what workflows they employ, deliberate or otherwise.


Live streaming

One of the consumption styles in this vein is to watch live streams, where folks work on stuff, figuring things out, building up solutions piece by piece, or sharing knowledge or experience in specific areas … in full view of an audience who are present there with that host, over the Internet. Moreover, in the live streams I’ve joined, it’s two-way. The viewers can interact with each other and with the host, via chat and other mechanisms.

It’s a fascinating idea, and one that caught my imagination last year, so much so that I thought I’d give it a try.


Plans for the first episode

Setting up a live stream involves a lot of jiggery pokery, a lot of stuff that’s new to me, so I thought I’d take my first steps into this new world with a simple first episode, so that I can keep an eye on things (such as the streaming mechanics, right now it feels like I’m getting a whole load of plates ready to spin at the top of thin poles) and start off at a gentle pace.

So we’ll spend the hour looking at Node.js flavoured JavaScript, and stretch our brain muscle a little by solving a couple of puzzles, using some features from the ES6 version of the language, and throwing in a few functional morsels. Node.js is a super important runtime for SAP Cloud Platform Cloud Foundry, so I think it’s always worth practising JavaScript when you can.


The schedule

There are two streaming schedules – the regular weekly Friday slot and the fortnightly Wednesday slot.

The regular weekly Friday slot

I stream regularly once a week on Fridays. It’s a one hour slot. I’m a morning person, which is one of the reasons the regular streaming slot is at 0800 UTC+0 (UK time).

That means the main weekly stream schedule looks like this going east around the globe:

The regular Friday slot starting at 0800 BST (Manchester):

Start time Time Zone Example City
0800 BST Manchester
0900 CEST Walldorf
1230 IST Bengaluru
1700 AEST Sydney

The fortnightly Wednesday slot

I also stream every fortnight (every 2 weeks), midweek on Wednesdays. This slot is in the afternoon, Manchester time, so I can catch US folks in their timezones.

The fortnightly Wednesday slot starting at 1500 BST (Manchester):

Start time Time Zone Example City
0900 CDT Chicago
1500 BST Manchester
1600 CEST Walldorf
1930 IST Bengaluru

Of course, regardless of time, you are all welcome to join. But there’s no way I can cover all timezones around the globe with a single slot, so I’m going to make sure each stream is are recorded for replay at a later date too – see the replays section elsewhere in this post.


How to watch

I’ll be streaming on Twitch, which is an excellent platform for live streaming all sorts of things, not least programming and coding topics, in the Science & Technology category. My home on Twitch is here:

https://twitch.tv/qmacro99

You can sign up for an account, and follow me. There are all sorts of features that Twitch has, far more than I can explain here (partly because I don’t know what they all are!) but the main feature for us is the ability to take part in discussions during the stream, with the chat facility. You can watch the live stream, and use the chat interface to converse with me and the other viewers. I’ve set my stream up so that the chat is also visible in my stream directly.

If you visit my home on Twitch right now, you’ll see the home screen that’s shown while I’m offline:

Below that you’ll also see some information that might come in handy:


Catch the replays

If you missed a live episode, you can watch the recordings. On my Twitch channel you’ll see a “Videos” link where you can get directly to the replays.

We’re also making the recordings available on YouTube, in the form of a playlist Hands-on SAP dev with qmacro in the SAP Developers channel – by the way, don’t forget to subscribe to the channel with the big red button:

Annotated links: For each recording on YouTube, there will be annotated hh:mm:ss links so you can jump straight to the part you’re looking for. One annotations blog post per episode – and the links are in the rightmost column in the table. This tweet shows an example of how you might use the annotated links feature.

 

Ep. Date Title & description with link to full video recording Annotated description with links to specific points in the videos
0 Friday
18 Jan 2019

Ep.0 – Getting our feet wet

In this initial episode of the “Hands-on SAP dev with qmacro” series, we take a brief look at what using SAP’s Cloud Application Programming Model in a Node.js context means for us JavaScript developers, and warm our brains up by solving some puzzles with a bit of ES6 flavoured code (with some functional aspects thrown in for good measure).

Watch replay on YouTube

Annotated links (Episode 0)
1 Friday
25 Jan 2019
Ep.1 – Setting up for the Node.js flavoured version of SAP’s Cloud Application Programming Model

While we warmed our grey matter up in the previous episode, in this episode we set up what we need to build with the Node.js (JavaScript) flavoured version of SAP’s Cloud Application Programming Model (CAPM). This version allows us to build locally, with tools on our own machines, so that’s what we’ll be doing.

Therefore, we use the SAP NPM registry to find & install the command line tool ‘cds’ that we can use to generate and manage Node.js based CAPM projects and also install the CDS language support for the VS Code editor, which comes in the form of an VS Code extension. Then we set up our Cloud Foundry environment on SAP Cloud Platform and install the ‘cf’ command line tool which we can use to interact with that environment.

Watch replay on YouTube

Annotated links (Episode 1)
2 Friday
01 Feb 2019

Ep.2 – Starting to build a bookshop backend service with CAPM

In the previous episode we set up our tools and development environment ready for some SAP Cloud Application Programming Model (CAPM) action of the Node.js (JavaScript) flavour. So now we’re ready to start exploring our first data and service definitions in the language of CAPM, i.e. CDS (Core Data & Services).

We follow the “Create a Business Service with Node.js using Visual Studio Code” tutorial on the SAP Developers tutorial navigator and start to explore what CAPM and CDS can do for us.

Watch replay on YouTube

Annotated links (Episode 2)
3

Friday

08 Feb 2019

Ep.3 – Special guest edition: Interview with core CAPM developers from the mothership!

This episode is rather special, in that I interview Christian Georgi from the core CAPM development team at the mothership in Walldorf. We talk CAPM, have some Q&A Christian shows us some cool live demos.

Watch replay on YouTube

Annotated links (Episode 3)
4 Wednesday
13 Feb 2019

Ep.4 – Debugging CAPM and a look at the cds REPL

We take a look at how we can use VS Code debugging facilities to debug CAPM services, and also start to explore the cds command line tool’s REPL (Read Evaluate Print Loop) environment.

Watch on YouTube

Annotated links (Episode 4)
5 Friday
15 Feb 2019

Ep.5 – Continuation of the CAPM Node.js bookshop tutorial

We continue working our way through the tutorial “Create a Business Service with Node.js using Visual Studio Code” on the SAP Developer Centre.

Watch replay on YouTube

Annotated links (Episode 5)
6 Friday
22 Feb 2019

Ep.6 – Extending the CAPM bookshop tutorial – hacking & learning

We’re pretty much at the end of the tutorial as it stands. But there’s always more to learn by hacking on it, to tweak and extend it. We do that in this episode, uncovering more features of CAPM and CDS.

Watch replay on YouTube

Annotated links (Episode 6)
7 Wednesday
27 Feb 2019

Ep.7 – Digging into the language server protocol, cds-lsp and Vim

One of the things we looked at briefly in the previous episode was the language server protocol (LSP) implementation for the CDS language, in the VS Code extension. In this midweek episode we explore getting a Vim LSP client working and connected to the cds-lsp server.

Watch replay on YouTube

Annotated links (Episode 7)
8 Friday
01 Mar 2019

Ep.8 – Using Axios, ES6, promises & pure functions to grab data

In Episode 6 we set out creating our mini Northwind service, called Northbreeze, and started to write some code to grab the Northwind data, exploring Axios as an HTTP client library that supports promises and (therefore) dot chaining. In this episode we continue on towards completing this code to produce CSV files as input to our CAP model, exploring pure functions along the way.

Watch replay on YouTube

Annotation links (Episode 8)
9 Wednesday
06 Mar 2019

Ep.9 – Continuing with data retrieval for Northbreeze

In episode 8 last Friday we were constructing the data retrieval script using Axios and promises. In this episode we continue to build that out, and then convert the data thus retrieved to CSV for loading into the database with cds deploy.

Watch replay on YouTube

Annotation links
(Episode 9)
10 Thursday
07 Mar 2019

Ep.10 – Finishing off the data retrieval mechanism in Node.js

Following the previous episode there’s a bit more work to do to finish off the data retrieval mechanism we have been building to extract data from the original Northwind service and turn it into CSV files that can be loaded into a persistence layer with ‘cds deploy’. In this episode we finish this off and load the data.

Watch replay on YouTube

Annotation links
(Episode 10)
11 Friday
08 Mar 2019

Ep.11 – A CAP project for “Geonames” & funcprog style with Chris Whealy

In this episode we have developer Chris Whealy as a guest, taking us through his personal project making use of Geonames data and built using CAP with Node.js. Along the way we look at Chris’s programming style which takes a lot from the functional programming world.

Watch replay on YouTube

Annotation links (Episode 11)
12 Friday
15 Mar 2019

Ep.12 – Exploring and understanding parts of @sap/cds JS – code & style

I had an itch to scratch, in that I wanted to be able to filter out columns in CSV files. In this episode we take a look at some of the JavaScript within the @sap/cds module – what it offers and how it’s written. We then see how some of that was useful in building a simple CSV filter mechanism.

Watch replay on YouTube

Annotation links (Episode 12)
13 Wednesday
20 Mar 2019

Ep.13 – Stdio-ifying the CSV filter mechanism

In the previous episode (Ep.12) we looked at a simple CSV filter utility. In this episode we improve it by giving it the ability to read from STDIN and write to STDOUT so it plays nicely in pipeline contexts. Then we’ll be ready to use it to finalise our data for our CAP based “Northbreeze” service.

Watch replay on YouTube

Annotation links (Episode 13)
14 Friday
22 Mar 2019

Ep.14 – Exploring CAP service level features and annotations

After a pleasant detour hacking together some CSV related utilities with Node.js we return to our Northbreeze CAP project and take a look at some of the service level features, looking how they can complement the data model, and playing around with some of the annotations available to us, to see what effect they have. We also take a look at fixing the issue we had with the boolean property :-0 back in Ep.10.

Watch replay on YouTube

Annotation links (Episode 14)
15 Friday
29 Mar 2019

Ep.15 – Starting to look at a frontend for our Northbreeze app

This session comes to you from the location of the SAP CodeJam event in the AOK offices in Frankfurt. In this episode we investigate at a few more cool features of CAP and CDS and start to look at a user interface for our Northbreeze app, and even get to serve it from the CAP runtime itself.

Watch replay on YouTube

Annotation links (Episode 15)
16 Wednesday
03 Apr 2019

Ep.16 – Getting to a basic frontend with Fiori Elements, and sandbox launchpad

Following on from the previous episode broadcast from the SAP CodeJam in Frankfurt, we continue moving towards a first UI using a sandbox Fiori launchpad and a basic Fiori elements app driven by a small set of annotations.

Watch replay on YouTube

Annotation links (Episode 16)
17 Friday
05 Apr 2019

Ep.17 – Digging into the annotation driven UI

We take a look at the simple UI that we created in the previous episode and look a little bit behind the scenes, to learn a bit more about annotations, OData calls and more.

Watch replay on YouTube

Annotation links (Episode 17)
18 Friday
12 Apr 2019

Ep.18 – A first look at CAP with Java

In this episode we take a break from Node.js and JavaScript, and take a first look at the SAP Cloud Application Programming Model with Java. Developer Evangelist Max Streifeneder is our expert for the episode, for an interesting and fun overview of what CAP with Java is all about.

Watch replay on YouTube

Annotated links (Episode 18)
19 Wednesday
17 Apr 2019

Ep.19 – Some fun with CAP related tooling

This being a midweek episode, we allow ourselves a little bit flexibility and look into developer tooling; we look a bit more at syntax highlighting in Vim, some more LSP usage and try to come up with a workflow for setting up to answer CAP questions on the SAP Community Q&A site.

Watch replay on YouTube

Annotated links (Episode 19)
20 Friday
19 Apr 2019

Ep.20 – Continuing with CAP and Java

Following on from Ep.18 where we took a first look at CAP with Java, in the SAP Web IDE, we continue our journey and look more closely at adding hooks and debugging. As a bonus, this is again led by our friend and my colleague Max Streifeneder!

Watch replay on YouTube

Annotated links (Episode 20)
21 Friday
26 Apr 2019

Ep.21 – CAP, Java, Maven and the cloud

This episode brings a selection of related topics. With Max Streifeneder we continue where we left off in the previous episode and then dig a little bit into Maven tooling. After that we switch back to our Northbreeze service and look at deploying to the Cloud Foundry environment on SAP Cloud Platform.

Watch replay on YouTube

Annotated links (Episode 21)
22 Wednesday
01 May
2019

Ep.22 – Live stream community share – dotfiles and Google Cloud Run goodness

In this midweek episode we enjoy a little off piste activity with two special guests from the #HandsOnSAPDev community. Ronnie Sletta describes his setup and takes us through his dotfiles for new machine setups, and Nabheet Madan shows us how he deployed a CAP project to Google Cloud Run.

Watch replay on YouTube

Annotated links (Episode 22)
23 Friday
03 May 2019

Ep.23 – Digging in to the sitregcapm project

In this episode we take a closer look at the project to rewrite the SAP Event Registration app backend using CAP, in the form of the sitregcapm repo on GitHub.

Watch replay on YouTube

Annotated links (Episode 23)
24 Friday
10 May 2019

Ep.24 – Going from local CAP to cloud CAP with MTA based deployments

In this episode we have Marius Obert who takes us on a journey from our local CAP development environment to the cloud. Specifically he shows us how to deploy a simple CAP project to SAP Cloud Platform Cloud Foundry environment and gives us some tips and tricks along the way.

Watch replay on YouTube

Annotated links (Episode 24)
25 Friday
24 May 2019

Ep.25 – System reset

The past week has been a little bit hectic and distracting, so I use this episode as a sort of “system reset” to figure out where things are, what we want to work on, and share some items that have come up recently.

Watch replay on YouTube

Annotated links (Episode 25)
26 Wednesday
29 May 2019

Ep.26 – Vim CDS plugin with new @sap/cds-lsp package

Now that the @sap/cds-lsp package is published to the public SAP NPM registry, it’s a good time to look how we can incorporate that into the Vim CDS plugin. Plus more SAP Cloud Platform Workflow goodness too!

Watch replay on YouTube

Annotated links (Episode 26)
27 Friday
31 May 2019

Ep.27 – Continuation of the Cloud Platform Workflow project

In this episode we continue where we left off in Ep.25, to build out the workflow scenario on SAP Cloud Platform, exploring features as we go for service and script tasks, and more.

Watch replay on YouTube

Annotated links (Episode 27)
28 Wednesday
05 Jun 2019

Ep.28 – Digging into Workflow user task UIs

Continuing on from the previous episode, we dig in a little deeper to user task UIs, looking at the Workflow API and task info, as well as the My Inbox API, to understand how the generic UI component actually works.

Watch replay on YouTube

Annotated links (Episode 28)
29 Friday
05 Jul 2019

Ep.29 – Restarting – catchup and stretching

This is the first episode for a few weeks, so it’s worth spending some time catching up with where things are, and having a bit of a warmup and stretch, brain-wise, so we can get back into things the right way, including a first look at mocked authorisations in CAP.

Watch replay on Twitch

30 Friday
19 Jul 2019

Ep.30 – More on CAP auth and Fiori Elements features

Following on from the previous episode we continue with digging into CAP authorisations and start to take a look at the new built-in Fiori Elements rendering feature in CAP 3.13.

Watch replay on Twitch

31 Wednesday
24 Jul 2019

Ep.31 – Digging into CAP’s fiori-preview

With 3.13 we saw the appearance of a nifty little feature available in the services via HTTP – the “Fiori preview”. In this episode we dig in a little bit to find out how that works. Express middleware? Yes please!

Watch replay on Twitch

32 Friday
26 Jul 2019

Ep.32 – Annotations to power the CAP fiori-preview

Now that we’re familiar with the fiori-preview feature in CAP, and understand (from the previous episode) how it actually works underneath, we now look a bit deeper at annotations that we can use to power the dynamically rendered Fiori Elements based displays.

Watch replay on Twitch

33 Friday
02 Aug 2019

Ep.33 – More CAP exploration

Following on from the previous couple of Friday episodes, we continue to explore CAP features, to see what we can find. As an experiment this episode’s description remains deliberately loose until we get down to it during the actual stream, so we can just follow our noses and see where we end up.

Watch replay on Twitch

34 Friday
23 Aug 2019

Ep.34 – Exploring actions and functions in CAP

In this episode we explore the “dark side” of the otherwise RESTful OData protocol (that’s fighting talk, I know!) and dig in a little bit to actions and functions. If you’ve encountered function imports in OData before, you’ll feel right at home.

Watch replay on Twitch

35 Friday
30 Aug 2019

Ep.35 – More on actions and functions in CAP

In this episode we pick up where we left off in the previous episode and continue to dig into actions and functions.

Watch replay on Twitch

36 Wednesday
11 Sep 2019

Ep.36 – Actions and value help in CAP

We get to look a bit more at the orthogonal parts of OData V4 in the form of actions (remember: may have side effects and may (might) not return data) and perhaps investigate value help with code lists.

Watch replay on Twitch

 


Plans

Once we’ve got our feet wet with the first episode, I plan to look at the Node.js flavour of SAP’s Cloud Application Programming Model (CAPM) (see Application Programming Model – start here) over the following weeks, but reserve the right to digress and follow interesting paths that lead from there. And who knows what we might cover beyond that.

I’ve already got guests lined up to join us in a near future live stream, direct from the awesome core team that’s designing and building out CAPM inside the mothership at SAP. Keep an eye out for details of the subsequent live stream episodes to catch who that is, and when!


Feedback

If you’ve managed to catch a live stream, or watch a recording, I’d love to hear from you, in the form of feedback at an episode-specific level. At the end of each episode I’ll remind you of the feedback form link, but you can visit the form any time. Note that I’m looking for episode-specific feedback, which means that you should select (from a dropdown) the episode you’re giving feedback for.

The feedback form is here: https://bit.ly/handsonsapdev-episodefeedback – thank you in advance!

 


Wrapping up

This post is already longer than I intended (perhaps partly down to the excellent Three’s Company brew I just enjoyed, from a local collaboration between Cloudwater, Magic Rock and J.W. Lees) so I’ll finish off by reminding you that the initial episode of this venture, episode zero, is this coming Friday 18 Jan at the time given above (relative to your local timezone).

I hope to see you online, and please don’t hesitate to take part in the discussion when you join!


Upcoming Episode

Date Fri 20 Sep 2019
Time 0800 BST (Manchester) // 0900 CEST (Walldorf) // 1230 IST (Bengaluru) // 1700 AEST (Sydney)
Title Ep.37 – Digging into annotations
Description In this episode we dig into annotations to get closer to an understanding of how value help works. There’s a long way to go, but we know the journey will be pleasant and interesting. Come along and enjoy the ride!

Get a reminder for this episode by checking out the event on Twitch, via the “Hands-on SAP dev with qmacro” series info page or by adding this series’ public Google Calendar to your own calendar system.


Updates

17 Jan 2019: I’ve created a public Google calendar that you can subscribe to and from where you receive event reminders, which are set to fire 1 day and 30 mins before the event starts: Hands-on SAP dev with qmacro Calendar.

I’ve also set up a series on Twitch and I’ll define each episode as an event in this series. You can go to Twitch, see the upcoming events, view the details and request reminders.

23 Jan 2019: Added an “Upcoming episode” section.

25 Jan 2019: Added a “Feedback” section.

12 Feb 2019: Reworked the “Schedule” section to include the new occasional midweek slot schedule and moved the episode replay links into the “Replays” section.

13 Feb 2019: Added the bit.ly link to this post (http://bit.ly/handsonsapdev).

20 Feb 2019: Reworked the Catch the replays section, adding links to the new annotated descriptions.

28 Feb 2019: Improved the Catch the replays section, adding each episode’s description, and separate links to the recordings on Twitch. Eventually we will have links to the recordings on YouTube also.

05 Mar 2019: Added a note about the annotated links blog posts to the Catch the replays section.

05 Apr 2019: Updated the Feedback section with a link to a new episode-specific feedback form.

12 Apr 2019: Changed the occasional midweek slot to a regular fortnightly cadence.

9 Comments
You must be Logged on to comment or reply to a post.
  • This is cool! I’ve been thinking about doing some live streaming of architecture conversations and diagrams, and twitch seemed a great platform. I’ll be curious to see how you get on.

  • Hi DJ. I just watched the stream for the first time this morning and I only have one word: AMAZING! Digging into what’s behind the tutorials is super interesting and useful, I really like this format and I can’t wait for the next stream!

    • Hey Pierre, first of all thanks so much for joining the live stream this morning and participating too, I really appreciate it. And thanks also for the feedback, that makes me very happy that you found this interesting and useful. Looking forward to seeing you join the next episode!

       

  • Hi DJ,

    Not sure when you can read this comment, but you may have floated the idea how twitch is helpful/useful in your most recent episode (August 23rd) and that got me thinking and respond here.

    How about making mp4 files downloadable somewhere, including here or on wiki, assuming both technical and privacy issues are taken care of?

    most of all, thank you for providing great content and driving the SAP ecosystem interaction.

    cheers, gm

    • Hi Gregory, that’s something that I try to do, albeit indirectly. Here’s the process, in a nutshell:

      1. broadcast episodes live on Twitch -> https://twitch.tv/qmacro99
      2. recordings of those episodes immediately available on Twitch – https://twitch.tv/qmacro99/videos,
      3. a pointer is added to this post to each episode’s details as well, including a link to the video, in the ‘Catch the replays’ section -> https://bit.ly/handsonsapdev#replays
      4. in the meantime, the recordings also exist locally to me as MP4 files
      5. I then annotate those MP4 recordings to create blog posts, which I publish, and the recordings themselves are then uploaded to YouTube to a playlist in the SAP Developers channel -> https://www.youtube.com/playlist?list=PL6RpkC85SLQAIntm7MkNk78ysDm3Ua8t0
      6. the links in the ‘Catch the replays’ section of this post are then updated with the YouTube video link and the annotation blog post link

      The key thing to realise that throughout this process, you can download the videos whenever you want, either from Twitch or from YouTube, with the youtube-dl utility program.

      Hope that helps – share & enjoy!

      dj

  • DJ,

    indirect is fine as long as the source is open and if i end up using the shareware i will also pay for it. cloud as it is, whether AWS, GCP, or any other, is not always available, so personal backups help to recover from the disasters.

    thank you for responding with a little bit of home work, gm

     

    • Cheers Greg. Note – youtube-dl is public domain software, not shareware. You can donate of course, if you wish, via the link.