Skip to Content
Personal Insights

Tech Aloud podcast – an introduction

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:

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!

 

3 Comments
You must be Logged on to comment or reply to a post.
  • Hi DJ,

    i’m a sucker for all things audio, including librivox, and i really appreciate your taking the initiative to read quality content aloud for the rest of us – a kind of lullaby to a geek, in my mind.

    i was toying with the idea of reading accounting manuals and posting them somewhere, but obviously that didn’t go too far. still, i can see two titles that are quite intriguing after listening to your rendition of “The Simplest Thing that Could Possibly Work” :

    1. Particularis de computis et scripturis
    2. Theorematum Quorundam Ad Numeros Primos Spectantum Demonstratio

    cheers and thx for that rss feed.

    rgds,

    gm

  • Thanks Greg, that’s good to hear – I appreciate the comment.

    Also, interesting idea about reading out stuff in Latin, might be quite relaxing …