Tech Aloud podcast - an introduction

[qmacro]

I started a new podcast called Tech Aloud, where I read aloud blog posts and articles so you can consume them on the go. There's no specific theme to the episodes I've published so far ... or is there?

Tech Aloud is a humble and simple new podcast that I've created to satisfy an itch - I wanted to use travel time to consume (in an audio format) articles and blog posts that I probably wouldn't otherwise get time to sit down read. There simply isn't enough time to keep up with all the interesting stuff that's published.

There wasn't a podcast that did that, so I created one, as I'm sure there are folks amongst you that are like me and also want to consume more, on the go.



Anyway, you can read more about it here in this other post on my home blog: New podcast - Tech Aloud which should tell you all you need to know, like how to subscribe (there's a growing list of podcast services there where it's already available), and a little bit more about the general idea.

Including the short introductory episode, Welcome to Tech Aloud, I've recorded and published 6 episodes so far. I've dipped into my article & blog post bookmarks and just recorded the first ones that jumped out at me. So there's definitely some randomness to what I've picked so far, from a practical perspective, but I've noticed a theme, or at least a relationship, amongst the episodes so far (this theme will change, I'm sure, over the subsequent episodes!) and thought I'd highlight it.

Here are the titles of the first podcast episodes thus far, along with the original article or blog post sources:

• ?It’s Steampunk now - Harald Kuck - 20 Aug 2019
  Source: https://blogs.sap.com/2019/08/20/its-steampunk-now/


• ?The Standard of Code Review - Google's Engineering Practices documentation
  Source: https://google.github.io/eng-practices/review/reviewer/standard.html


• ?Domain-Specific Languages Guide - Martin Fowler - 28 Aug 2019
  Source: https://www.martinfowler.com/dsl.html


• ?DSL Q & A - Martin Fowler - 9 Sep 2008
  Source: https://www.martinfowler.com/bliki/DslQandA.html


• ?The Simplest Thing that Could Possibly Work, A conversation with Ward Cunningham, Part V - Bill Venn...
  Source: https://www.artima.com/intv/simplest.html

I included harald.kuck's specific post on Steampunk because it was something that I'd wanted to read soon but hadn't yet got round to. Nice work Harald and team!

But the other articles are more general, and some are what I'd call classics.

The Domain Specific Language Q&A from Martin Fowler is already over a decade old but still super relevant - perhaps even more relevant - today. I am mindful of internal DSLs almost every day, when I use the SAP Cloud Application Programming Model (CAP), specifically in the Node.js flavour. If you look at the source code of some of the core libraries, you'll find stylised JavaScript that can be considered, at least to some extent, an internal DSL.

You don't even have to look behind the curtain of CAP Node.js to see an internal DSL standing proud - look at how the CDS Query Language (CQL) is made available almost as a "little language" within the JavaScript that you write inside of custom handlers. There's a simple example of this in Step 10 of the developers.sap.com tutorial Create a Business Service with Node.js using Visual Studio Code (look at the UPDATE mechanism):

module.exports = (srv) => {



  const {Books} = cds.entities ('my.bookshop')



  // Reduce stock of ordered books

  srv.before ('CREATE', 'Orders', async (req) => {

    const order = req.data

    if (!order.amount || order.amount <= 0)  return req.error (400, 'Order at least 1 book')

    const tx = cds.transaction(req)

    const affectedRows = await tx.run (

      UPDATE (Books)

        .set   ({ stock: {'-=': order.amount}})

        .where ({ stock: {'>=': order.amount},/*and*/ ID: order.book_ID})

    )

    if (affectedRows === 0)  req.error (409, "Sold out, sorry")

  })



  // Add some discount for overstocked books

  srv.after ('READ', 'Books', each => {

    if (each.stock > 111)  each.title += ' -- 11% discount!'

  })



}

Moreover, for those forward thinking enough to embrace the CDS REPL (see my post Monday morning thoughts: cloud native for more on REPLs), there's a rich seam of CDS API just ready to be mined - look at this tiny example from Getting Started - Define Services:

cds.load('srv/cat-service') .then (cds.compile.to.edmx)

While not a complete internal DSL it sure feels like a language specifically designed to flow, especially in the way that it positively embraces and even celebrates whitespace.

Talking of flow, the SAP Cloud SDK comes to mind. It has a wonderfully fluent interface which you can see in this simple example (taken from a tutorial that will feature in one of this year's SAP TechEd App Space missions, so don't forget to come by the Developer Garage next week in Las Vegas!):

BusinessPartnerAddress

        .requestBuilder()

        .getAll()

        .select(

                BusinessPartnerAddress.BUSINESS_PARTNER,

                BusinessPartnerAddress.ADDRESS_ID,

                BusinessPartnerAddress.CITY_NAME,

        )

        .execute({url:'http://localhost:3000/v2'})

        .then(xs => xs.map(x => x.cityName))

        .then(console.log)

Look at the way that chain of calls "flows" from one part to the next - some parts being provided by custom functions, others by language features such as 'then'.

In a nice reference that completes the circuit loop, it may delight you to know that "fluent interface" was in fact co-coined by the author of the two items on DSLs that feature in the Tech Aloud episodes so far - Martin Fowler.

Martin Fowler is one seriously big thinker. Another is Ward Cunningham (as one of my all-time heroes, I'd made it my mission to meet him at OSCON, which I did in 2003), inventor of the Wiki, and pioneer of design patterns and extreme programming (XP).

There's a multi-part interview that Bill Venners did with Ward, and the conversation and thinking is wonderful. If you want to read more from that interview, find the other parts (I - IV) here: https://www.artima.com/intv/simplest.html.

And moving on from thinking about writing "the simplest thing that could possible work", how about reviewing it? This is where the Google Code Review standards come in. Google released to the public their Code Review guidelines very recently, and I was keen to take a look. So I've decided to read through each of the parts in How to do a code review, as wisdom that we might all be able to learn from (in fact as we speak I've got the second part of that series waiting to publish on the podcast right now).

Anyway, that's about it for now. Please consider subscribing to the Tech Aloud podcast - it's already available for example on Player FM, Pocket Casts, Spotify, TuneIn, and (soon, fingers crossed!) Apple iTunes Podcasts. Of course, you can simply take the podcast RSS feed URL and plug it into your own favourite podcast player:

https://anchor.fm/s/e5dc36c/podcast/rss

Thanks!