DJ Adams

Blog

  1. Notes on simple agentification of a CAP service

    A short note-to-self on what I did when trying out the new agents plugin for CAP.

  2. Balancing context size and callable tool metadata with CAP's MCP adapter

    Some notes on both sides of the per_action_tool setting of CAP's MCP adapter plugin.

  3. Knowledge and netiquette in today's AI era

    What I took from a couple of great podcast episodes I listened to this morning.

  4. Timeless principles, agnostic design and the power of CAP's abstractions

    The timeless principle of agnostic design, aka minimal assumptions, is strongly present in CAP. In this post I explain what this principle represents, based on the corresponding section of Daniel Hutzel's keynote at reCAP 2026.

  5. reCAP 2026 talk resources

    Resources related to our talk at reCAP 2026.

  6. Computing memories

    Some brief thoughts on history and how we used to have to make things work, sometimes in painstaking detail.

  7. Blogging in en-GB

    I've changed the language declaration on my website to en-GB. Here's why.

  8. CAP service authentication at design time and in production

    In this short post I explain how the "failsafe" production auth mechanism is designed for resources served in a CAP context.

  9. Book Overflow and two architectural patterns in CAP

    In this short post I note a couple of software architecture patterns that were mentioned in a recent Book Overflow episode, patterns that are clear and present in CAP.

  10. Local-first dev with CAP Node.js - mocking messaging

    In this post I provider a taster of what's possible regarding mock messaging in CAP Node.js local-first development.

  11. Local-first dev with CAP Node.js - mocking remote services

    In this post I provider a taster of what's possible regarding mock remote services in CAP Node.js local-first development.

  12. Local-first dev with CAP Node.js - mocking auth

    In this post I provider a taster of what's possible regarding mock auth in CAP Node.js local-first development.

  13. Local-first dev with CAP Node.js

    Here's an overview of a set of related posts on mocking, in the context of local-first development with CAP Node.js.

  14. Local-first dev with CAP Node.js - mocking data

    In this post I provider a taster of what's possible regarding mock data in CAP Node.js local-first development.

  15. CDS expressions in CAP - notes on Part 6

    Notes to accompany Part 6 of the mini-series on the core expression language in CDS.

  16. CDS expressions in CAP - notes on Part 5

    Notes to accompany Part 5 of the mini-series on the core expression language in CDS.

  17. CDS expressions in CAP - notes on Part 4

    Notes to accompany Part 4 of the mini-series on the core expression language in CDS.

  18. CDS expressions in CAP - notes on Part 3

    Notes to accompany Part 3 of the mini-series on the core expression language in CDS.

  19. CDS expressions in CAP - notes on Part 2

    Notes to accompany Part 2 of the mini-series on the core expression language in CDS.

  20. CDS expressions in CAP - notes on Part 1

    Notes to accompany Part 1 of the mini-series on the core expression language in CDS.

  21. Genres, cuids and a bit of AWK

    Using AWK to process the Genres data from the CAP bookshop sample.

  22. Improving the SAP Community together, one comment at a time

    A suggestion on how we can work together to make the SAP Community better.

  23. Shift left with CAP

    In this post I posit that shifting left in our CAP based solutions is something that we should be striving to do.

  24. Series of "Did You Know" videos

    Here's a collection of pointers to short "Did You Know" videos from the Developer Advocates, highlighting small but interesting and useful aspects of various SAP tech tools, frameworks and products.

  25. Modifying queries, replacing the WHERE clause

    Here's a quick post to explain how to modify existing query objects in CAP, specifically using the CAP Node.js cds.ql API.

  26. Path expressions, nested projections, aggregations and expressions in queries with CQL and CXL in CAP

    A brief exploration of some of the features of CAP's powerful query and expression languages, inspired by our journey into CXL in the current Hands-on SAP Dev series.

  27. OData Deep Dive rewrite in the open

    I'm refreshing the content of the OData Deep Dive series of tutorials, in the open.

  28. Modules, modularity & reuse in CDS models - part 5 - digging into @capire/common

    In this post I look at various mechanisms that @capire/common has that makes it "active" as a reuse package.

  29. Constraints, expressions and axioms in action

    In this blog post I meditate on how declarative constraints are realised in CAP, using the power of the underlying database.

  30. Modules, modularity & reuse in CDS models - part 4 - from passive to active with @capire/common

    Starting with a simple use of the published @qmacro/common reuse module, I then turn to @capire/common for a first look at what I call an "active" reuse module.

  31. Modules, modularity & reuse in CDS models - part 3 - publishing the simple reuse package

    Taking the simple passive reuse package created in part 2, I now publish it to the NPM registry which is part of GitHub Packages.

  32. Modules, modularity & reuse in CDS models - part 2 - creating a simple reuse package

    Following on from part 1 in this series, I take a step back and look at the fundamentals of creating and working with a module, locally in this part, using the NPM workspace concept.

  33. Why I use services.cds in simple CDS model examples

    The services.cds filename is special, which is why I make use of it.

  34. Modules, modularity & reuse in CDS models

    An overview of the blog posts in the series "Modules, modularity & reuse in CDS models".

  35. Modules, modularity & reuse in CDS models - part 1 - an introduction

    In this first post of a new series I look at the using directive in CDS modelling, and how NPM modules can be fundamental building blocks in modularity and reuse.

  36. A new Hands-on SAP Dev mini-series on the core expression language in CDS

    Hands-on SAP Dev is back soon, kicking off in January with a new mini-series on CAP, specifically on CXL, the core expression language in the CDS family.

  37. A simple exploration of status transition flows in CAP

    In this post I explore the new Status-Transition Flows in CAP with a simple example.

  38. Some ramblings on simple CDS modelling with CDL

    A brief note-to-self after digging in to some simple constructs in CDS modelling.

  39. Hands-on domain modelling with CAP's CDS at UKISUG Connect

    A quick overview of the hands-on workshop I'll be running at UKISUG Connect this year.

  40. Quiet cds test output - two ways

    Reducing CAP server log output during tests, in two different ways, via a profile encapsulated set of log level configurations, or via the new cds test command.

  41. Modelling contained-in relationships with compositions in CDS

    A short study of the features of CDS for modelling classic contained-in relationships, with a focus on the details, and a lean towards anonymous aspects.

  42. Using @capire modules from GitHub Packages

    Here's how to access and use the @capire namespaced modules that reside in the NPM registry which is part of GitHub Packages.

  43. CDS source formatting and readability

    Embracing a modern approach to source code formatting for human-centric modelling in CAP

  44. Upcoming talks in autumn 2025

    I'm writing this mostly to organise myself and get my preparations in order!

  45. Auto formatting extensionless Bash scripts in Neovim

    Here's what I did to make the combination of the Bash language server and shfmt work with Editorconfig settings for Bash script files that don't have extensions.

  46. Neovim configuration for file and module navigation in CDS models

    In this post I describe how I extended my Lua-based Neovim configuration for CDS filetypes to improve navigation to referenced files and modules.

  47. Excluding specific diagnostics in Neovim

    Here's what I did to be able to filter out certain diagnostic messages in Neovim.

  48. A reCAP intro to the cds REPL

    Here's a summary of my talk on the cds REPL at this year's reCAP event.

  49. A modern and clean Neovim setup for CAP Node.js - configuration and diagnostics

    In this post I describe my re-worked basic setup for working with CAP Node.js in Neovim, focusing on the configuration and digging into the LSP based diagnostic facilities.

  50. Editing Markdown in a Neovim environment

    Here are some notes I made when digging into my tools for editing Markdown source.

  51. Point free coding and function composition

    In this post I explore and show examples of the concepts of point free coding, of chains of functions through which data flows, and of function composition.

  52. Adjusting the preview width in Telescope's horizontal picker

    Here's how I adjusted the width of the preview window in Telescope's horizontal picker.

  53. FP, function chains and CAP model loading

    Understanding functional programming approaches, no matter how trivial, can help in other areas. Here I explain how being comfortable with function chains helped in working out why a required (but unused) service was being loaded into the overall CDS model in a CAP project.

  54. Array.prototype.reduce and the optional initial value

    Today I learned about the subtlety of the optional initialValue parameter for the Array prototype's reduce method in JavaScript.

  55. Functional programming resources

    I've created quite a bit of FP related content in the past but it's somewhat scattered across different platforms and in different formats and I can't remember what or where it all is. So this is a meta post in which I point to all the resources (that I can remember that) I've created on the topic.

  56. How I run executables in containers

    Here's a quick post explaining how I might typically containerise an executable. This is in the context of my aim to not "pollute" my base OS (at the bare metal level) with any installs, as far as I can, as well as to remain platform independent and abstract.

  57. Level up your CAP skills by learning how to use the cds REPL

    These are notes I wrote for my talk at SAP Inside Track Madrid on 20 March 2025. I wrote them partly to think about what I wanted to say, and partly to share the info in written form too. Note that the idea is to introduce the concepts and show some basic examples for cds REPL "initiates". Nothing too exotic.

  58. Migrating GitHub issue based URL bookmarks to wallabag

    In this post I outline how I migrated my collection of reading list bookmarks, stored as issues in a GitHub repo, to wallabag which I'm now self-hosting.

  59. TASC Notes - Part 9

    Notes on part 9 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  60. TASC Notes - Part 8

    Notes on part 8 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  61. TASC Notes - Part 7

    Notes on part 7 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  62. CAP Node.js plugins - part 3 - writing our own

    This blog post accompanies part 3 of a three part series where we explore the CDS Plugin mechanism in CAP Node.js. This post is about using the knowledge we've gained to write our own plugin.

  63. CAP Node.js plugins - part 2 - using the REPL

    This blog post accompanies part 2 of a three part video series where we explore the CDS Plugin mechanism in CAP Node.js. This post is about discovering and exploring service details with introspection.

  64. CAP Node.js Plugins

    Here's a summary of the resources relating to the CAP Node.js Plugins series.

  65. TASC Notes - Part 6

    Notes on part 6 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  66. Functions as first class citizens in SICP Lecture 1A

    Exploring functions as first class citizens in SICP Lecture 1A and drawing parallels with queries in CAP.

  67. TASC Notes - Part 5

    Notes on part 5 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  68. TASC Notes - Part 4

    Notes on part 4 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  69. The elements of programming with respect to CDL and SICP

    Drawing parallels between the elements of programming in SICP and CDS's Conceptual Definition Language.

  70. The Art and Science of CAP

    A ten part series where we dive deep into CAP with its creator Daniel Hutzel, where we take both philosophical and practical angles.

  71. TASC Notes - Part 3

    Notes on part 3 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  72. TASC Notes - Part 2

    Notes on part 2 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  73. Creating the new Tech Aloud intro and outro music

    Reviving my Tech Aloud podcast and creating new intro and outro music with JavaScript.

  74. Flattening the hierarchy with mixins

    Exploring how mixins in CDS help flatten a hierarchy between application and foundation teams.

  75. Five reasons to use CAP

    Five compelling reasons to embrace SAP's Cloud Application Programming Model, from its framework-first philosophy to its agnostic design principles.

  76. Separating concerns and focusing on the important stuff

    Thinking properly about what separation of concerns means in the context of CDS and CAP.

  77. Restricting access via facets with masked elements

    Exploring how to restrict access via projections with masked elements in CDS.

  78. Keeping things simple in domain modelling with CDS

    Keeping things simple in CDS domain modelling and remembering to involve the domain expert.

  79. Immutable layers, file deletion and image size in Docker

    Digging into how the immutability of Docker image layers means you have to think carefully about creating and deleting content when building an image.

  80. CAP Node.js plugins - part 1 - how things work

    In this first of a three part series of blog posts accompanying a corresponding video series, we explore the CDS plugin mechanism in CAP. This post is about understanding how the plugin mechanism works.

  81. TASC Notes - Part 1

    Notes on part 1 of The Art and Science of CAP, a mini series with Daniel Hutzel exploring the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  82. Setting up a cache server for apt packages

    Setting up an apt-cacher-ng based cache server for Debian apt packages in my homeops context.

  83. New source for LXD images on Crostini

    Finding a new source for LXD images on ChromeOS Crostini after the default became unavailable.

  84. Using lazydocker with SSH-based remote contexts

    A quick hack to work around the current issue with lazydocker and SSH-based remote Docker context definitions.

  85. Automatic validation in OData and REST calls with CAP

    Exploring the automatic validation of data coming into CAP-based service endpoints via OData and REST.

  86. reduce - the ur-function

    Why I think of reduce as the ur-function, a primitive building block from which other functions like map and filter can be constructed.

  87. Highest value in JS - different ways

    Exploring different ways to find the highest value in a JavaScript array as part of the Developer Challenge.

  88. Turning an OData expand into a cds.ql CQL query with a projection function in CAP

    Turning an OData expand into a cds.ql CQL query with a projection function in CAP.

  89. Enabling document fragment links for headings in SAP Community blog posts

    Creating a bookmarklet to enable document fragment links for headings in SAP Community blog posts.

  90. Digging into CSN diffs for CDS models

    Building a csndiff script to understand CSN changes as I build up CDS models incrementally.

  91. CodeTalk interview - living and working on a narrowboat

    Appearing on CodeTalk to discuss living and working on my narrowboat.

  92. Using ARG in a Dockerfile - beware the gotcha

    Learning about the subtle gotcha with ARG and FROM instruction ordering in Dockerfile definitions.

  93. Defining a custom 'after' handler in CAP with 'each'

    Exploring the special behaviour of using the each parameter name when defining an after handler in CAP.

  94. Obtaining auth code grant type OAuth 2.0 tokens for Google APIs with a script

    Writing a script to obtain OAuth 2.0 bearer tokens for Google API calls using the auth code grant type.

  95. Controlling automatic HTTP requests in CAP Node.js design time loops

    Controlling automatic HTTP requests during CAP Node.js design time development loops.

  96. Simple script for previewing CDS models in CSN - cdsray

    Building a simple cdsray script for previewing CDS models in their CSN representation.

  97. Using @cap-js/sqlite in CF for your CAP services

    Using the cap-js/sqlite package in Cloud Foundry for lightweight CAP service deployments.

  98. Running non-production CAP services in CF

    Running non-production CAP services in Cloud Foundry without the overhead of production infrastructure.

  99. Easily add an explicit cds.requires.db to your CAP project's package.json

    Using jq to easily add an explicit cds.requires.db entry to a CAP project's package.json.

  100. Improve your CAP dev container shell prompt

    Improving the shell prompt in a CAP dev container for a better development experience.

  101. Avoid design time CAP server restarts when maintaining local data files

    Avoiding unnecessary CAP server restarts when maintaining local CSV data files during design time.

  102. CAP, CDS, CDL, CSN and jq - finding associations

    Using jq to parse association information from CSN, the internal representation of CDS definitions in CAP.

  103. CAP, CORS and custom headers

    Digging into CORS support in CAP, covering CORS headers, preflight requests and custom header handling.

  104. Test drive Joule's generative AI features in SAP Build Code now!

    Announcing the GA of SAP Build Code and the limited-time opportunity to test drive Joule's generative AI features.

  105. Curating a collection of jq functions

    Curating a personal collection of jq functions and exploring how the jq module system works.

  106. ISO content for common CAP types

    Exploring the NPM package that provides default ISO-based content for CAP common types like countries and currencies.

  107. Quick conversion of multiple values using with_entries in jq

    Demonstrating how jq's with_entries is a powerful combination of to_entries and from_entries for value conversion.

  108. Opening files from the terminal in BAS dev spaces

    Opening files from the terminal in SAP Business Application Studio dev spaces using the code command.

  109. Successful double CodeJam in Wroclaw and Warsaw

    Reporting on two successful SAP CodeJams in Wroclaw and Warsaw, Poland.

  110. Ghost cratch fitted

    Fitting a ghost cratch to the stern of my narrowboat for weather protection.

  111. Exploring codespaces as temporary dev containers

    Exploring GitHub Codespaces as ephemeral, temporary dev container environments.

  112. Accuracy and precision in language

    Arguing for accuracy and precision in language, especially the distinction between blogs and blog posts.

  113. Developing CAP in containers - three ways

    Exploring three different ways of developing CAP applications in containers.

  114. Battlestation 2024

    Sharing a picture of my 2024 desk setup on the narrowboat.

  115. A simple jq REPL with tmux, bash, vim and entr

    Building a simple jq REPL with tmux, Bash, Vim and entr for exploring JSON datasets.

  116. Using the docker CLI in a container on macOS

    Explaining how to use the Docker client CLI from within a container on macOS.

  117. From Twitter to Mastodon

    Moving off Twitter at the end of 2023 and explaining the reasons for the switch to Mastodon.

  118. Tmux plugin development with a local repo

    Writing a simple Tmux plugin to learn how plugin development works with a local repo.

  119. TIL - Two Tmux Plugin Manager features

    Discovering two useful Tmux Plugin Manager features while revisiting my working environment setup.

  120. Solving the SAP TechEd Easter Egg on the Web

    Solving the SAP TechEd 2023 Easter Egg, a Node.js puzzle found at the event in Bengaluru.

  121. Devtoberfest - the best developer prep for SAP TechEd

    Explaining why Devtoberfest is a great way for developers to prepare for SAP TechEd.

  122. Bash shell expansion inside double quotes

    Exploring which Bash shell expansions still work inside double quotes in the context of an API challenge.

  123. OData query operations and URL encoding the system query options with curl

    Using curl to send OData query operations with system query options that contain whitespace, letting curl handle the URL encoding.

  124. Curing my stove aboard the narrowboat

    Curing my new stove aboard the narrowboat on the first cool day since launch.

  125. Mercia Marina to Shobnall Fields and Burton-on-Trent

    Cruising from Mercia Marina to Shobnall Fields and Burton-on-Trent on the canal.

  126. Resources for navigating the canal network

    Sharing resources and tools for navigating the UK canal network.

  127. Oil change and a visit to Mercia Marina

    Performing the first oil change service on my narrowboat engine during a visit to Mercia Marina.

  128. SAP CodeJam report - service integration with CAP in Guetersloh, DE

    Reporting on delivering an SAP CodeJam on service integration with CAP in Guetersloh.

  129. Selecting the related endpoints from a GitHub API response using jq's with_entries

    Using jq's with_entries to select the related API endpoints from a GitHub API response.

  130. SAP CodeJam on Service Integration with CAP in Brescia

    Reporting on running an SAP CodeJam on service integration with CAP in Brescia, Italy.

  131. Living on a narrowboat - layout details of the stern

    Describing the layout details of the stern on my narrowboat.

  132. Improving my interactive jq workflow with ijq, bash and tmux

    Improving my interactive jq workflow by capturing expressions from ijq for command line use.

  133. More on the comma as generator, and streaming with select in jq

    Exploring the subtleties of the comma as a generator and streaming with select in jq.

  134. Double SAP BTP goodness in Isernhagen

    Reporting on a great double BTP event at Inwerken AG in Isernhagen near Hannover.

  135. Recognising patterns and embracing the stream

    Refactoring a jq implementation of an LED number display by recognising patterns and embracing the stream-oriented nature of the language.

  136. Learning from community solutions on Exercism - part 3

    Dwelling on more small details in jq solutions to Exercism exercises.

  137. Living on a narrowboat - the stove as the heart of the home

    Choosing a multifuel stove for my narrowboat, covering the factors I considered and why the stove is the heart of the home on the canal.

  138. Learning from community solutions on Exercism - part 2

    Continuing to learn from community solutions on Exercism's jq track.

  139. Learning from community solutions on Exercism - part 1

    Learning from community solutions on the jq track in Exercism, starting with some interesting patterns.

  140. SAP community memories

    Contributing memories from the early days of the SAP Community to celebrate its 20th anniversary.

  141. A deep dive into OData and CDS annotations

    Taking a deep dive into OData and CDS annotations following my live stream series on OData basics.

  142. SAP CodeJam on the btp CLI and APIs in Heilbronn

    Reporting on delivering an SAP CodeJam on the btp CLI and APIs in Heilbronn.

  143. SAP CodeJam on Service Integration with CAP in Utrecht

    Reporting on running an SAP CodeJam on Service Integration with CAP in Utrecht.

  144. Living on a narrowboat - embracing constraints

    Embracing the constraints of living on a narrowboat as a positive force.

  145. Working from a narrowboat - Internet connectivity

    Exploring the internet connectivity options for working from a narrowboat.

  146. I'm moving onto a narrowboat

    Announcing my decision to have a narrowboat built and to live and work from it.

  147. Learning from exploring a question on jq

    Exploring different ways of achieving a simple JSON reformulation goal with jq and explaining my thinking.

  148. Array push with autovivification in jq

    Making a note about array push with autovivification in jq while working on Advent of Code.

  149. Managing resources on SAP BTP - what tool do I choose?

    A way to think about the different tools available for managing resources on the SAP Business Technology Platform and when to use each one.

  150. Extracting blog post dates from URLs with jq

    Using jq to extract and sort blog post dates embedded in URLs from a JSON array of GitHub issues.

  151. Some notes on modular JSON Schema definitions

    Jotting down some notes on understanding how a modular JSON Schema definition might be constructed.

  152. More Untappd data explorations with jq - my top ranking beer types (part 3)

    Wrapping up my Untappd data exploration with the final ranking of my favourite beer types.

  153. More Untappd data explorations with jq - my top ranking beer types (part 2)

    Continuing my Untappd data exploration to determine my top ranking beer types.

  154. Stop asking for slides in advance

    I'm giving a talk next month and was asked by the organiser to send my slides to them no later than two weeks before the event. Hmm.

  155. More Untappd data explorations with jq - my top ranking beer types (part 1)

    Exploring my Untappd data to discover my top ranking beer types, starting with the data preparation.

  156. Untappd data with jq - my top brewery countries

    Exploring my Untappd checkin data with jq to find my top brewery countries.

  157. Understanding jq's SQL style operators JOIN and INDEX

    Exploring jq's JOIN and INDEX operators based on a Stack Overflow answer.

  158. Summing and grouping values with jq

    Here's yet another note-to-self on using jq, this time to transform a flat list of order totals and dates into a summary of total order values by year.

  159. Reshaping data values using jq's with_entries

    Exploring a JSON file of valid tutorial tags using jq's with_entries to reshape the data.

  160. Multiple level filters in jq

    Using jq to shape JSON representations of OData with filtering at two levels.

  161. Products by supplier in OData and jq

    Comparing OData resource requests with equivalent JSON shaping using jq.

  162. Exploring JSON with interactive jq

    Using ijq, the interactive jq wrapper, to explore JSON data with immediate visual feedback.

  163. JSON object values into CSV with jq

    I wanted to grab a CSV version of a JSON representation of an entityset in the Northwind OData service. Here's how I converted the JSON structure into CSV with jq, and along the way, I talk about arrays, objects, iterators, object indices, variables, identity, array construction and format strings.

  164. Exploring GitHub repo name distribution with jq

    Exploring the distribution of name prefixes for SAP-samples repositories on GitHub using jq.

  165. Converting strings to objects with jq

    Converting a list of fully qualified GitHub repository names into structured JSON objects with jq.

  166. Some thoughts on jq and statelessness

    Reflecting on jq's stateless nature after reading about zq as an alternative.

  167. Bash notes 3

    Discovering more Bash language features from community solutions to Exercism exercises.

  168. A classic example of yak shaving, and some stream editing

    Descending through multiple levels of classic yak shaving and ending up learning some stream editing.

  169. Bash notes 2

    Picking up more Bash insights from Exercism solutions including case statement features.

  170. Bash notes

    Learning a few things from reading through a neat solution to a Bash track exercise in Exercism.

  171. Understanding jq's reduce function

    Understanding jq's reduce function by relating it to the equivalent in JavaScript.

  172. Setting up my own Cloud Foundry

    Describing my journey getting a local Cloud Foundry up and running on Kubernetes.

  173. Exercism and jq

    Exploring what a jq track might look like on the Exercism learning platform.

  174. SAP Tech Bytes: btp CLI - new home for configuration

    Noting the updates to where the btp CLI configuration is stored by default.

  175. How I got involved in the SAP community

    Summarising how I got involved in the SAP community from the earliest days.

  176. Allowing my intangible core to catch up with the rest of me...

    Reflecting on narrowboat trips and allowing my intangible core to catch up with the rest of me.

  177. Truncation and neat terminal output

    Exploring the psFormat Docker configuration option and striving for neat terminal output.

  178. Controlling Chrome from the CLI

    Using the chrome-cli tool to open URLs in different tabs from the command line.

  179. Setting up hadolint - a Dockerfile linter

    Setting up hadolint as a Dockerfile linter in my development environment.

  180. Getting BTP resource GUIDs with the btp CLI – part 2 - JSON and jq

    Exploring how the btp CLI supports JSON output and how to parse it with jq.

  181. Getting BTP resource GUIDs with the btp CLI - part 1

    Learning how to use the btp CLI to determine resource GUIDs in a BTP global account.

  182. UTFRW - Unofficial TechEd Fun Run / Walk / Roll - Share Your Pics!

    Inviting people to walk, run or roll 5K during SAP TechEd week and share pictures.

  183. Exploring fff part 2 - get_ls_colors

    Continuing to read and learn from the fff file manager source code, focusing on the get_ls_colors function.

  184. Embracing jq and JSON

    Finding that exploring objects in a complex JSON structure is not as scary as I thought with jq.

  185. Sourcing vs executing in Bash

    Checking the value of $0 to determine whether to source rather than execute a script.

  186. SAP Tech Bytes: btp CLI - autocompletion

    Setting up command autocompletion for the btp CLI.

  187. Using functions more

    Exploring the benefits of using Bash functions more as a sweet spot between aliases and scripts.

  188. SAP Tech Bytes: btp CLI - managing configuration

    Understanding and managing the btp CLI client configuration.

  189. Improving shell fu with practice

    Practising shell commands to improve my skills and expose myself to new knowledge.

  190. SAP Tech Bytes: btp CLI – logging in

    Logging in with the btp CLI and finding a subaccount for subsequent activities.

  191. Exploring fff part 1 - main

    What I learned from starting to read the source code of the fff file manager, focusing on the main function.

  192. SAP Tech Bytes: btp CLI - installation

    Installing the btp CLI to start exploring its features for BTP administration.

  193. Learning by rewriting - bash, jq and fzf details

    One of the ways I learn is by reading and sometimes rewriting other people's scripts. Here I learn more about jq by rewriting a friend's password CLI script.

  194. Today's TIL trio

    Three mini TILs from today on minimum JSON, using tee, and netstat options.

  195. Session switching with the tmux menu

    Here's a way to get a simple session switcher in tmux using a popup menu.

  196. tmux output formatting

    Here's what I learned today about FORMATS in tmux output.

  197. Reopening pull requests and GITHUB_ACTOR

    The GITHUB_ACTOR on a re-opened pull request reflects the person re-opening it, not the original creator.

  198. Unix tooling - join, don't extend

    Reading a 1984 paper by Pike and Kernighan helped crystallise an important axiom in Unix tool design about joining programs rather than extending them.

  199. Early thoughts on Warp

    Some very early thoughts on Warp, the pro terminal designed for everyday use.

  200. The APC SMT750IC UPS works with the Synology NAS DS1621+

    Successfully configuring the APC SMT750IC UPS with the Synology NAS DS1621+ via USB for automatic shutdown.

  201. Remote access to Docker on my Synology NAS

    Setting up remote command line access to the Docker install on my Synology NAS in the simplest way possible.

  202. Adding a drive to my Synology NAS

    A brief summary of how things went adding a drive to my Synology DS1621+ NAS.

  203. Equality in tech

    A short statement on supporting equality in tech.

  204. Supporting developers with sponsorship

    Using the sponsors facility on GitHub to support developers whose work I value.

  205. Notes on Markdown linting - part 2

    More on Markdown linting, this time in the context of GitHub Actions.

  206. Notes on Markdown linting - part 1

    What I found out when I started to look into linting Markdown content.

  207. Solving mysterious unrendered markdown headings

    Getting to the bottom of why some headings in my Markdown content were not being rendered properly.

  208. Unpacking Bash shell tips from a GitHub Actions workflow

    Unpacking Bash shell tips from a GitHub Actions workflow step, focusing on IFS and awk usage for pull request info.

  209. GitHub Actions workflow browser

    A simple workflow browser built with Bash, gh and fzf to help refer to previous workflow definitions while writing new ones.

  210. Producing JSON with jq for appending issue titles

    Learning how to use jq to produce JSON while writing a script to enhance Thinking Aloud journal entry titles.

  211. SAP Tech Bytes: Exploring SAP-samples with gh and fzf

    Discovering SAP-samples repositories by exploring them from the command line with gh and fzf.

  212. Mainframes, SDSF and GitHub Actions

    The combination of GitHub Actions workflows, mainframes and SDSF that I cannot get out of my head.

  213. New tmux panes and windows in the right directory

    How to be in the right directory when creating a new window or pane in tmux.

  214. Deeper connections to everyday tools

    Wanting to learn more about the everyday tools I use, because with some things ignorance is not bliss.

  215. Two-phase video uploads with YouTube API and curl

    How to use the YouTube API to upload a video with curl using a two-phase approach.

  216. La Pavoni maintenance successful

    Notes on successfully carrying out maintenance on my La Pavoni espresso machine that may help others too.

  217. Mass deletion of GitHub Actions workflow runs

    A simple cleanup script for mass-deleting GitHub Actions workflow runs using gh, jq, fzf and the GitHub API.

  218. A new journal experiment - Thinking Aloud

    I'm trying out a new way of sharing thoughts in a GitHub issues based journal style blog called "Thinking Aloud".

  219. Aborting a script with parameter expansion

    Using the :? form of shell parameter expansion to abort a script if a required parameter value is not set.

  220. SAP TechEd Developer Keynote - Info Central

    Gathering all the information about the SAP TechEd 2020 Developer Keynote and related resources in one place.

  221. SAP Tech Bytes: Approuter User API Service

    Kicking the tyres of the new User API Service available in the SAP approuter NPM package.

  222. fzf - the basics part 2 - search results

    More on the fzf basics, this time focusing on controlling and understanding the search results.

  223. Thoughts on video content

    Thoughts on video content form, length, frequency and more, especially in a developer advocacy and learning context.

  224. fzf - the basics part 1 - layout

    What I learned from reading the first part of the fzf README about controlling the layout and appearance.

  225. Do less and do it better

    Consolidating and improving existing skills rather than adding more in 2021, and the inspiration behind that decision.

  226. Columnar layout with AWK

    A breakdown of a simple AWK script to format values into neatly aligned columns.

  227. From Classics to Developer Advocate

    Telling the story of how I went from reading Classics at university to becoming a Developer Advocate at SAP.

  228. Updating your fork of the Developer Keynote repository

    Showing how to update your fork of the SAP TechEd Developer Keynote repository with new material.

  229. Waiting for jobs, and the concept of the shell

    How Bash's wait builtin deepened my understanding of Bash scripting as a language.

  230. SAP TechEd 2020 Channel 1 at home

    Watching all the SAP TechEd 2020 Channel 1 content from the comfort of my TV at home.

  231. Implicit values in Bash for loop construct

    Bash's for loop construct can use implicit values by iterating over the positional parameters when no list is specified.

  232. UTFRW - Unofficial TechEd Fun Run / Walk

    Organising a virtual 5K fun run and walk during SAP TechEd 2020.

  233. SAP TechEd Developer Keynote DK100 - The Story

    Telling the story behind the SAP TechEd Developer Keynote DK100 that we built together.

  234. My SAP TechEd 2020 - what I'm looking forward to

    Sharing what I'm looking forward to at SAP TechEd 2020 as a virtual event.

  235. An overview of SAP Developers video content

    Providing an overview of the wealth of video content for SAP developers on the YouTube channel.

  236. The myriad meanings of pwd in Unix systems

    Exploring the myriad meanings of pwd in Unix and Linux systems based on a Twitter poll with varied results.

  237. Computer Unit 1979

    A transcription of an article about the arrival of the Computer Unit, a PDP-11/34, at my school in 1979 which became the early focus of a fascination with computing that has never left me.

  238. The subtle art of quoting newline characters

    How backslash continuation in the shell is more subtle and more beautifully shell-like than it might first appear.

  239. Case modification operators in parameter substitution

    In addition to the usual ways of uppercasing strings, Bash 4 brought case modification operators to the parameter substitution family.

  240. MID$ and shell parameter expansion

    The rich and varied abilities in Bash for accessing and manipulating values in variables through shell parameter expansion.

  241. Understanding declare

    Exploring the Bash builtin declare, its relationship to typeset and local, and how it can be used to set variable attributes.

  242. Desnowballification with set -o errexit

    Using set -o errexit at the start of scripts to make them more robust and prevent error snowballing.

  243. Improving my shell scripting

    I'm using a style guide along with the shellcheck and shfmt tools to help me improve the quality and consistency of my shell scripts.

  244. curl and multipart/form-data

    Discovering how curl handles multipart/form-data including reading from standard input.

  245. Checking a command is available before use

    Learning a useful pattern for checking whether a command is available before using it.

  246. Using exec to jump

    Exploring how the exec builtin in Bash replaces the current process with a new one.

  247. A new learning source for shell scripting

    Discovering Mr Rob's dotfiles and live streams as a new learning source for shell scripting.

  248. Shell parameter expansion with :+ is useful

    Using the shell parameter expansion form :+ for expanding optional values.

  249. Reducing writing friction

    A simple script to reduce writing friction and make it easier to start and publish blog posts.

  250. Programmer's Day Mission 2020

    Announcing the Programmer's Day mission on the SAP Community for earning a special badge.

  251. You can mask sensitive hostnames with wildcards and host aliases

    The HOSTALIASES feature works well when combined with wildcard host definitions in SSH config to mask sensitive hostnames.

  252. The open square bracket [ is an executable

    In a shell script, the open square bracket symbol is not syntax but an executable.

  253. Why we have /bin/ and /usr/bin/

    The simple historic reason why Unix systems have both /bin/ and /usr/bin/ directories.

  254. String.prototype.replace() can take a function

    You can use a function to dynamically provide the replacement value in a JavaScript replace operation.

  255. continue-on-error can prevent a job step failure causing an action failure

    Using continue-on-error in a GitHub Actions job spec to prevent failures from being flagged when a job step fails.

  256. git diff can emit different exit codes

    Combining git diff exit codes and the POSIX negation operator to control GitHub Actions job step execution based on git changes.

  257. In an mta.yaml file you can use the service-name parameter to point to an existing resource

    In mta.yaml files you can use the service-name parameter to point to an existing service instance with a different name than the resource.

  258. SAP NPM packages now on npmjs.org

    Explaining the migration of SAP Node.js packages from the SAP NPM registry to npmjs.org.

  259. Removing the knob on a La Pavoni steam valve

    How I went about removing the knob from the shaft of the steam valve on my La Pavoni lever coffee machine.

  260. SAP Community Coding Challenge 2 - Finalists

    Presenting the voting thread for the finalists of the second SAP Community Coding Challenge.

  261. SAP Community Coding Challenge 2 - Contestants

    Listing the successful contestants in the second SAP Community Coding Challenge.

  262. Remote mount setup on the Raspberry Pi

    Setting up mount points on a Raspberry Pi for connecting to an Apple Airport Time Capsule and Google Drive.

  263. SAP Community Coding Challenge 2 - Update

    Providing an update on the progress of the second SAP Community Coding Challenge.

  264. Terminal Tip: a CF remote monitor script

    Building a script to find and remotely monitor an ongoing Cloud Foundry multi-target app deployment.

  265. SAP Community Coding Challenge Nr.2

    Announcing the second SAP Community Coding Challenge with a fun puzzle to solve.

  266. Terminal Tip: remotely monitor a CF deployment

    Remotely monitoring an ongoing Cloud Foundry MTA deployment from the terminal.

  267. Terminal Tip: switching CF targets

    Switching between Cloud Foundry targets efficiently from the command line.

  268. Terminal Tip: parsing CF app logs

    Parsing Cloud Foundry application log output with shell tools for better readability.

  269. Terminal Tip: truncating CF output

    Truncating wide Cloud Foundry CLI output to make it more readable in the terminal.

  270. Initial Pi configuration via Ansible

    Performing initial configuration of the freshly booted Raspberry Pis using Ansible.

  271. Code at Home episodes

    A summary of the Code at Home episodes streamed live and available as recordings on YouTube.

  272. Let's learn to "Code at Home"

    Information on the Code at Home initiative, what it is and what you need to join in.

  273. Starting out with Raspberry Pi experiments

    Background on why I started experimenting with Raspberry Pis and the hardware components I set up.

  274. Preparing the OS image

    How I prepared the base OS image for each of the Raspberry Pis in the Brambleweeny cluster.

  275. Finding the Pis on the network

    How to find freshly booted Raspberry Pis on the network so they can be configured further.

  276. Brambleweeny Cluster Experiments

    An index of posts in the Brambleweeny Cluster Experiments series about building a Raspberry Pi cluster.

  277. Mini adventures with MTAs and the Cloud Foundry CLI

    Exploring MTAs and shell pipeline techniques with the Cloud Foundry CLI.

  278. Scripting Cloud Foundry activities in trial

    Sharing a script for recreating my Business Rules environment in the Cloud Foundry trial using the CLI.

  279. My learning list for 2020

    Sharing my learning aspirations for 2020 and reflecting on the previous year.

  280. Help us to help you - good questions beget good answers

    Suggesting key aspects of composing good questions to help community members provide better answers.

  281. Mission 'Use CAP and SAP Cloud SDK to Extend S/4HANA' - an overview

    Outlining the Use CAP and SAP Cloud SDK to Extend S/4HANA mission created for SAP TechEd 2019.

  282. CAP is important because it's not important

    Considering what CAP really is, what it gives us, and why its transparency is what makes it important.

  283. Shell power and simplicity

    Reflecting on the often overlooked power and simplicity of shell programming concepts.

  284. Submit suggestions for Tech Aloud during SAP TechEd 2019

    Explaining how to submit content suggestions for the Tech Aloud podcast during SAP TechEd 2019.

  285. Tech Aloud podcast - an introduction

    Providing an introduction to my Tech Aloud podcast and the themes emerging from the first episodes.

  286. New podcast - Tech Aloud

    Introducing my new Tech Aloud podcast where I read tech articles and blog posts aloud.

  287. Happy Programmers Day!

    Celebrating Programmers Day and reflecting on a couple of people who have inspired my growth as a programmer.

  288. Hitchhiker's style in Sea of Sorrows

    Exploring a possible link between a scene in Alien: Sea of Sorrows and a scene in The Hitchhiker's Guide To The Galaxy.

  289. Computed field example in CAP

    Showing one way of using computed properties in CAP using CDS and service events in Node.js.

  290. We can do better than 'polynimbus'

    Questioning the use of the word polynimbus and advocating for clearer language in tech.

  291. The Observer's Book of JS Style

    Reflecting on JavaScript coding style through the lens of an Observer's Book approach.

  292. David Edward Adams

    Remembering my dad, David Edward Adams, who passed away peacefully on 11 July 2019.

  293. Double SAP CodeJam Athens - a report

    Reporting on delivering two SAP CodeJams in Athens on CAP and Workflow.

  294. Revisiting UI5 on CodeTalk

    Revisiting the subject of UI5 in a CodeTalk session with Marius Obert and Ian Thain.

  295. First thoughts on the 2019 Stack Overflow Developer Survey results

    Sharing initial observations on the 2019 Stack Overflow Developer Survey results.

  296. ES6, reduce and pipe

    In learning about functional programming, one thing that's worked for me is to take my time, and not rush over fundamental concepts. In fact, like a good beer or whisky, a fundamental concept is something to savour, to enjoy at a leisurely pace.

  297. Vim, Markdown and writing

    Rebuilding my writing workflow around Vim and Markdown for a more focused experience.

  298. Housekeeping

    Tidying up my blogging infrastructure and moving to a new domain and platform.

  299. Monday morning thoughts: looking back and forwards

    I look back on the posts in this series, reflect upon the journey we've made, and think about what 2019 might hold for us.

  300. Monday morning thoughts: digging deeper

    I think about the tools we use in our day-to-day activities, the feeling I have that I'm just scratching the surface with regards to their capabilities, and what I plan to do about it in 2019.

  301. Monday morning thoughts: indirect influence

    On how our work can directly and even indirectly influence those that come after us, and about what this means for how we should act.

  302. Monday morning thoughts: learning media and mechanisms

    I think about the different ways I learn, and wonder how that translates to how we learn in the SAP developer ecosphere.

  303. Monday morning thoughts: rethinking like the web

    I revisit some principles that help us "think like the web" and think about them in the context of today's SAP technology landscape and community.

  304. Monday morning thoughts: longevity and loose coupling

    I think about the importance of core technologies, and how the arrival of functions-as-a-service might be merely the next incarnation of an idea that's existed for a while.

  305. Monday morning thoughts: on starting blogging

    On what made me start blogging, and on the reasons to start blogging that might resonate with you, if you've not yet made that step.

  306. Monday morning thoughts: exploring reuse

    I think about reuse and extension, in the context of the Application Programming Model for SAP Cloud Platform, and mindful of Björn Goerke's SAP TechEd 2018 keynote message in Barcelona - "keep the core clean".

  307. Monday morning thoughts: dynamic language

    Musings on a particular function definition in JavaScript, and how it represents beauty and practicality in equal measure.

  308. Set up VS Code on Chrome OS for local Application Programming Model development

    In this post I walk through the process I used to set up a development environment for CAP on my Chromebook.

  309. Monday morning thoughts: big school and community

    On my experience going from primary school to secondary school - "big school", how that parallels our collective move from on-prem to the cloud, and how the community is more important than ever in this transition.

  310. SAP Cloud Application Programming Model (CAP) - start here

    An overview of the key resources for folks wanting to get started with CAP.

  311. Monday morning thoughts: more on ABAP in the cloud

    Following a previous post on the subject, I think a bit more about the SAP Cloud Platform ABAP Environment, inspired by the conversations around the subject at SAP TechEd in Las Vegas last week.

  312. Monday morning thoughts: impostor syndrome

    On the impostor syndrome, how it relates to me, and one of the possible causes.

  313. Monday morning thoughts: growth is upwards

    In this post, I think about how we grow, how we improve ourselves by adding to our knowledge and experience, and consider that our growth is sometimes uphill but almost always rewarding.

  314. Monday morning thoughts: Workflow Forms and the definition of a developer

    I think briefly about the definition of a developer, and in that context look at the advent of Workflow Forms, a major new addition to the functionality of the Workflow service on SAP Cloud Platform.

  315. Monday morning thoughts: ABAP in the cloud

    I think about the new SAP Cloud Platform ABAP Environment, what it is, what it isn't, and why I think it's a great move.

  316. My take on Wired's Google & URLs article

    Sharing my discomfort with Google's rethinking of URLs as reported by Wired.

  317. Monday morning thoughts: considering GraphQL

    On GraphQL, and its relationship with existing ideas for managing data and structured exposure to that data over a wire protocol.

  318. Monday morning thoughts: a good blog post

    What makes a good blog post, and also what writing such a post does for the author, too.

  319. Monday morning thoughts: OData

    I think about OData, in particular where it came from and why it looks and acts like it does. I also consider why I think it was a good protocol for an organisation like SAP to embrace.

  320. Monday morning thoughts: the cloud is the computer

    I think about what the future of programming in an enterprise environment might look like, and realise that it makes sense to consider that the cloud itself is the new computer.

  321. Monday morning thoughts: mainframes and message documentation

    I think about mainframes and a message documentation aspect from the mainframe world that, while originally proprietary, is a big plus for operators and developers alike and something I'd love to see return.

  322. SAP CodeTalk sessions

    Listing my SAP CodeTalk sessions with Ian Thain over the years.

  323. Monday morning thoughts: local http servers and containerisation

    I look back on an idea surfaced by a hero of mine, and think about how that idea laid the path for today's containerisation initiatives.

  324. Monday morning thoughts: what not how

    In this post, I think about how we program, about the way we describe what it is that we want the computer to do for us, and look at what has become for me the canonical example of the difference between 'what' and 'how'.

  325. Monday morning thoughts: abstraction

    I think about abstraction, the power and facility it affords, and consider CDS as one example of a modern abstraction language.

  326. Monday morning thoughts: curiosity and understanding

    I think about how curiosity can lead to a better understanding of things, and give a specific example concerning CDS and the new Application Programming Model for SAP Cloud Platform.

  327. Monday morning thoughts: developers and advocacy

    I think about what it means to me to be a part of the Developer Relations team, and talk a bit about evangelism, outreach and advocacy.

  328. Monday morning thoughts: programming models

    I think about the idea of the programming model and consider the occurrence of such over the recent years in the SAP development ecosphere.

  329. Interview with Rui Nogueira on the new Application Programming Model for SAP Cloud Platform

    In this post you'll find a transcript of an interview between me and Rui Nogueira on the new Application Programming Model for SAP Cloud Platform. There's also a link to the audio version, available via Coffee Corner Radio.

  330. Monday morning thoughts: community engagement

    I think about some of the basic ingredients of a good online community, and describe what I'm going to try to do to engage more with the SAP Community.

  331. Monday morning thoughts: Core Data Services

    What Core Data Services (CDS) is, what it does, and why we should make it a priority to learn more about.

  332. Monday morning thoughts: the learning continuum

    I contemplate the idea of the learning continuum, and think about the fact that we're all learning together, which is a good thing.

  333. Monday morning thoughts: programmers and identity

    On how some programmers identify strongly with a particular language, consider the meanings of 'programmer', 'coder' and 'developer', and what it means for us as the SAP enterprise programming landscape changes.

  334. Collaboration tools

    Setting out my preferences for collaboration tools that support realtime multi-user editing.

  335. The Business Rules service - overview and getting started

    Some resources to help you get started with this service on SCP.

  336. Monday morning thoughts: milestones

    I look back at changes and developments that I consider milestones in SAP's technology history, and muse on some of the developments today that we'll consider milestones in the future.

  337. Monday morning thoughts: functions - what functions?

    Musings on the concept of functions-as-a-service, what it means, and what it's good for.

  338. Balancing features with simplicity

    Considering the balance between features and simplicity, prompted by a ChromeOS forum thread.

  339. Monday morning thoughts: containers and silence

    On the silence of workstations and what that represents to me, and the new ability to look at maintaining software and services in a completely different way - via containers.

  340. Monday morning thoughts: editors and editing

    I look at how the editor environments that we come across in our daily work are different, and, as those differences might grow and expand as we become cloud native, how we bridge the contrast in facilities with core obsessions such as correct indentation and whitespace.

  341. Monday morning thoughts: debugging approach and Greasemonkey revival

    Thinking about debugging approaches and reviving Greasemonkey for improving the web experience.

  342. Monday morning thoughts: upload / download in a cloud native world

    On how our modus operandi is often at odds with the true nature of cloud computing.

  343. Monday morning thoughts: a cloud native smell

    On the importance and design of URLs, and the opacity of cattle vs the individuality of pets.

  344. Introduction to SAP Cloud Platform Workflow - Summary

    Yesterday I gave a webcast for ASUG entitled "Introduction to SAP Cloud Platform Workflow". This is a short post that pulls together all the resources related to that webcast.

  345. Scripting the Workflow API with bash and curl

    There's an API for the SAP Cloud Platform Workflow service. Let's explore!

  346. Monday morning thoughts: cloud native

    What does it mean to be "cloud native"?

  347. Becoming an SAP Mentor Alumnus

    Reflecting on becoming an SAP Mentor Alumnus after years of community involvement.

  348. Debugging Fiori and UI5 - Materials

    A collection of pointers to material related to debugging UI5.

  349. Thoughts on what's next for the SAP Community

    My thoughts on the SAP community (small 'c') and the SAP Community platform.

  350. Apps Script - Privacy Policy

    This is the Privacy Policy for the Apps Scripts made available for use.

  351. Discovering SCP Workflow - Service Tasks

    Wrapping up with a look at service tasks.

  352. Discovering SCP Workflow - Script Tasks

    Taking a look at script tasks.

  353. Discovering SCP Workflow - Recommendation UI

    Looking at how the UI is put together.

  354. Discovering SCP Workflow - Component Startup

    In this post we'll look into how a task UI starts up, where it gets the right data to display, and how it interacts with the My Inbox "host" app.

  355. Discovering SCP Workflow - User Tasks

    Looking at the user task - present recommendations.

  356. Discovering SCP Workflow - Workflow Definition

    Now that we've covered how to kickstart a workflow instance, It's time to look at the overall picture of what we're building.

  357. Discovering SCP Workflow - Service Proxy

    In this post I present a small proxy service I wrote to handle the minutiae of initiating a new workflow instance.

  358. Coming Home

    On joining SAP as a Developer Advocate.

  359. Discovering SCP Workflow

    A ten part in-depth series exploring the SAP Cloud Platform Workflow service.

  360. Discovering SCP Workflow - Using Postman

    Using Postman to explore and interact with the SCP Workflow API.

  361. Discovering SCP Workflow - Instance Initiation

    In this post we explore the part of the SCP Workflow API that deals with workflow instances, and look at how we initiate a new workflow instance, paying particular attention to how we request, and then use, a cross site request forgery (XSRF) token.

  362. Consumption-based SCP Pricing - Initial Thoughts

    Looking at the the new pricing approach for SAP Cloud Platform.

  363. Discovering SCP Workflow - The Monitor

    Notes on the workflow monitor app that is part of the SAP Cloud Platform Workflow service.

  364. Things I do to make my work life better

    Notes on how I try to approach practical aspects of my working life.

  365. SCP Business Rules Roadmap - 5 Observations

    Sharing five observations on the SAP Cloud Platform Business Rules service roadmap.

  366. SAP Cloud Platform Pricing

    Looking into SAP Cloud Platform pricing and finding it less than straightforward.

  367. Fix Blink

    Providing a bookmarklet to fix the distracting blinking text in the timesheet system.

  368. Functional programming - baby steps

    A gentle introduction to some core concepts in functional programming for those just starting out.

  369. Meeting Request Details

    More on courtesy and respect at work.

  370. Google Cloud Functions + Sheets + Apps Script + Actions On Google = WIN

    Combining Google Cloud Functions, Sheets, Apps Script and Actions on Google into a perfect storm of technology.

  371. YABP - Yet Another Blogging Platform

    Reflecting on my history of blogging platforms and the latest move.

  372. SAP on the Google Cloud - exploring the possibilities

    The era of the software defined datacentre is truly upon us.

  373. Best practices for mobile reporting

    To put together a mobile reporting solution, there's a lot to consider. In this post, we show you how to start off and remain on the right track to deliver a solution that really works for your users.

  374. The beauty of recursion and list machinery

    Exploring the beautiful patterns inherent in recursion and list processing in functional programming.

  375. Reaching out to the new new kingmakers

    Sharing insights from the SAP Developer Advisory Board meeting on SAP's commitment to connecting with developers.

  376. Debugging SAP Fiori apps - the fifth "D"

    It's all very well designing and building a delightful Fiori app. But what about the long tail - supporting that app through its lifetime, with fixes and changes that come along? There's a fifth "D" to the SAP Fiori development mantra, and that "D" is for "Debugging".

  377. Excluding with vim's wildignore

    Getting the wildignore setting to work properly in vim for excluding directories like node_modules from file searches.

  378. Better collaboration through chemistry

    Reflecting on better collaboration through understanding and chemistry while working alongside a client on Fiori.

  379. F3C Parts 9 and 10 - Functors

    Exploring functors as part of my FunFunFunction Companion series.

  380. F3C Part 8 - Promises

    Exploring promises as part of my FunFunFunction Companion series.

  381. F3C Part 7 - Recursion

    Exploring recursion as part of my FunFunFunction Companion series.

  382. F3C Part 6 - Currying

    Exploring currying as part of my FunFunFunction Companion series.

  383. F3C - A FunFunFunction Companion Series

    Introducing my FunFunFunction Companion series on functional programming in JavaScript.

  384. F3C Part 5 - Closures

    Exploring closures as part of my FunFunFunction Companion series.

  385. F3C Part 4 - Reduce advanced

    Exploring advanced uses of reduce as part of my FunFunFunction Companion series.

  386. F3C Part 3 - Reduce basics

    Exploring the basics of reduce as part of my FunFunFunction Companion series.

  387. F3C Part 2 - Map

    Exploring the map function as part of my FunFunFunction Companion series.

  388. F3C Part 1 - Higher-order functions

    Exploring higher-order functions as part of my FunFunFunction Companion series on functional programming.

  389. The Fiori revolution - disruption at its best

    Three disruptive aspects of SAP Fiori and why they are important for enterprises in the digital era.

  390. Community and Collaboration at SAP Inside Track Manchester

    Reporting on the community and collaboration at SAP Inside Track Manchester 2016.

  391. Understanding the SAP Fiori Cloud Edition

    Providing an overview of the SAP Fiori Cloud Edition, how it works and what benefits it brings.

  392. Top 10 misconceptions about Fiori

    Addressing the top ten misconceptions and misunderstandings about SAP Fiori.

  393. FOFP 2.1 A look at filter

    Looking at the filter higher-order function as part of the fundamentals of functional programming.

  394. FOFP Fundamentals of functional programming

    Notes and resources for an introductory lecture on the fundamentals of functional programming at Xaverian College.

  395. FOFP 1.5 Creating functions

    Creating and composing functions as part of the fundamentals of functional programming.

  396. FOFP 1.4 A different approach with map

    Introducing the map function as a different approach to list processing.

  397. FOFP 1.3 Some basic list processing

    Exploring basic list processing with imperative and functional approaches.

  398. FOFP 1.2 Trying things out

    Setting up an environment to try out functional programming concepts interactively.

  399. FOFP 1.1 Introduction

    Introducing the fundamentals of functional programming with a definition and some context.

  400. Language minutiae and learning to SWIM

    Discovering small language details in Clojure while solving puzzles and learning to SWIM.

  401. Finding a wonderland number

    Solving a Wonderland Clojure Kata puzzle as a small evening exercise in functional thinking.

  402. Enlightenment in action

    On my journey to learn Clojure by solving 4Clojure challenges.

  403. "fiux2" Week 7 - Build Your Own SAP Fiori App

    Covering the final week of the openSAP Build Your Own SAP Fiori App in the Cloud course.

  404. 4Clojure Puzzle 66

    Solving 4Clojure puzzle 66 on my journey to learning more Clojure through online puzzles.

  405. "fiux2" Week 6 - Extend SAP Fiori Apps

    Covering week 6 of the openSAP Fiori course on extending SAP Fiori apps.

  406. "fiux2" Week 5 - Enhance an SAP Fiori Master Detail App

    Covering week 5 of the openSAP Fiori course on enhancing a master-detail app.

  407. The SAP Fiori Launchpad as a dashboard for my running KPIs

    Experimenting with using the SAP Fiori Launchpad to surface my running KPIs as live tiles.

  408. Quick HCP title hack with the Navigation Manager

    Hacking the HCP cockpit title with the Navigation Manager using the Chrome Developer Tools.

  409. "fiux2" Week 4 - Create Your First SAP Fiori App

    Covering week 4 of the openSAP Fiori course on creating your first SAP Fiori app.

  410. "fiux2" Week 3 - Get Ready to Create Your First App

    Covering week 3 of the openSAP Fiori course on getting ready to create your first app.

  411. The evolution of the SAP community

    Looking at how the SAP community has evolved over the years as I join the new Mentors Advisory Board.

  412. "fiux2" Week 2 - Design Your First SAP Fiori App

    Covering week 2 of the openSAP Fiori course on designing your first SAP Fiori app.

  413. "fiux2" Week 1 - Get to know Fiori UX

    Covering week 1 of the openSAP Fiori course 2016 edition on getting to know Fiori UX.

  414. "fiux2" - The openSAP Fiori Course - 2016 Edition

    An overview of the blog posts in the series about the 2016 openSAP course on Fiori.

  415. Building blocks of language, structure and thought

    As I travel on my path to perhaps what I deem as some sort of enlightenment, back in time via Clojure to one of the great ancestors of language, structure and computational thought (Lisp), I continue to come across a simple theme.

  416. The future of app building on the SAP HANA Cloud Platform

    Exploring one particular facet of the multi-faceted SAP HANA Cloud Platform and the future of app building.

  417. Digital devolution in local authorities - putting people first

    In a couple of weeks' time, Bluefin Solutions is running a one day event on delivering digital devolution in local authorities. If you look closely there's a clear user-centric pattern that is emerging.

  418. Impromptu JS session at UKISUG15

    Running an impromptu JavaScript session at UKISUG15 to introduce the language behind Fiori.

  419. Coffee-time JavaScript recreation

    In preparing for co-presenting a hands-on session at SAP TechEd EMEA this coming week in Barcelona, I came across a chunk of JavaScript. In this post I try to improve it with robustness and immutability in mind.

  420. Speaking at SAP TechEd EMEA 2015

    Looking forward to speaking at SAP TechEd EMEA 2015 in Barcelona with a packed schedule.

  421. Celebrating the engine of the Fiori revolution - the 30UI5 ebook

    Releasing a downloadable ebook version of my 30 Days of UI5 blog post series to celebrate the UI5 1.30 milestone and SAP TechEd 2015.

  422. Breathing through the reduction meditation

    In this post I look even more closely at a simple Clojure implementation of a reduce function.

  423. My journey to Clojure

    I'm learning Clojure. Slowly, but hopefully surely.

  424. A meditation on reduction

    Looking at a version of the reduce function written in Clojure, from Do Things: a Clojure Crash Course.

  425. Give me a browser, and I'll give you the world

    Exploring how a web-only developer workflow is possible right now using cloud-based tools.

  426. The advent of UI5 1.30 and what it means for us

    Reflecting on the milestone UI5 1.30 release and what it signifies for the toolkit's maturity.

  427. Cookies

    Stating plainly that this site uses cookies and that is how the web works.

  428. Building blocks for the future normal

    Arguing that understanding UI5 is key to embracing the future normal of SAP with S/4HANA and Fiori.

  429. The origin of becoming a fundamental enabler for Fiori

    30 Days of UI5 - day 30 by Sam Yen.

  430. Revisiting the XML Model

    30 Days of UI5 - day 29 by DJ Adams.

  431. UI5 Version Info

    30 Days of UI5 - day 28 by DJ Adams.

  432. A non-techie PM's view of UI5

    30 Days of UI5 - day 27 by Jon Gregory.

  433. UI5 - looking back and forward

    30 Days of UI5 - day 26 by DJ Adams.

  434. The experimental Client operation mode

    30 Days of UI5 - day 25 by DJ Adams.

  435. An introduction to sap.ui.define

    30 Days of UI5 - day 24 by DJ Adams.

  436. Taming the Resource Model Files

    30 Days of UI5 - day 23 by Nathan Adams.

  437. Merging lists with UI5

    30 Days of UI5 - day 22 by Chris Choy.

  438. Spreading the UI5 Message

    30 Days of UI5 - day 21 by DJ Adams.

  439. Fragments and Minimum Viable Code

    30 Days of UI5 - day 20 by DJ Adams.

  440. A Short UI5 Debugging Journey

    30 Days of UI5 - day 19 by DJ Adams.

  441. MVC - Model View Controller, Minimum Viable Code

    30 Days of UI5 - day 18 by DJ Adams.

  442. UI5 and Fiori - The Story of Open and Free

    30 Days of UI5 - day 17 by John Appleby.

  443. UI5 and Coding Standards

    30 Days of UI5 - day 16 by DJ Adams.

  444. The UI5 Support Tool - Help Yourself!

    30 Days of UI5 - day 15 by DJ Adams.

  445. Speeding up your UI5 app with a Component preload file

    30 Days of UI5 - day 14 by John Murray.

  446. Multi language support out of the box - UI5's pedigree

    30 Days of UI5 - day 13 by DJ Adams.

  447. Base Classes in UI5

    30 Days of UI5 - day 12 by Thilo Seidel.

  448. Handling Dates with the Date Picker

    30 Days of UI5 - day 10 by James Hale.

  449. Bootstrapping UI5 Locally and in the Cloud

    30 Days of UI5 - day 9 by DJ Adams.

  450. User Notifications with the Message Popover

    30 Days of UI5 - day 8 by Sean Campbell.

  451. The App Descriptor

    30 Days of UI5 - day 6 by Thilo Seidel.

  452. OpenUI5 Walkthrough

    30 Days of UI5 - day 5 by DJ Adams.

  453. Creating Native Applications with UI5

    30 Days of UI5 - day 4 by John Murray.

  454. Semantic Pages

    30 Days of UI5 - day 3 by DJ Adams.

  455. Expression Binding

    30 Days of UI5 - day 2 by DJ Adams.

  456. Welcome to 30 Days of UI5!

    30 Days of UI5 - overview and day 1 by DJ Adams.

  457. Lightweight notifications with the Message Strip

    30 Days of UI5 - day 11 by DJ Adams.

  458. JavaScript Do's and Don'ts for UI5

    30 Days of UI5 - day 7 by DJ Adams.

  459. Email discipline

    Email is asynchronous, and that's a good thing.

  460. JSON List Binding and maps

    Exploring JSON List Binding and the JavaScript Map object in the context of a UI5 app.

  461. openSAP Experiences

    Sharing my experiences with the openSAP learning platform and some suggestions for improvement.

  462. This Week in Fiori (2015-16)

    Covering week 16 of Fiori news including the Ariba Total User Experience.

  463. This Week in Fiori (2015-15)

    Covering week 15 of Fiori news including SAPPHIRE NOW and d-code event previews.

  464. This Week in Fiori (2015-14)

    Covering week 14 of Fiori news with ABAP, OData and UI5 content.

  465. This Week in Fiori (2015-13)

    Covering week 13 of Fiori news including the Build Your Own SAP Fiori App openSAP course.

  466. This Week in Fiori (2015-12)

    Covering week 12 of Fiori news including Mastering SAP Technologies and more.

  467. Making Information More Useful

    Explaining my approach to making information more accessible and useful through links and references.

  468. The maker's schedule, restraint and flow

    My thoughts on schedules and saying 'no'.

  469. This Week In Fiori (2015-11)

    Reviving the This Week in Fiori series for 2015.

  470. Why I'm Staying Close to UI5

    Explaining why I'm staying close to UI5 in response to an article about staying clear of it.

  471. Can I build a Fiori app? Yes you can!

    Making the case that building Fiori apps is achievable and explaining what it involves.

  472. 10 tips to get you started on your Fiori development journey

    Offering ten practical tips for getting started on a Fiori development journey.

  473. UI5 features for building responsive apps

    Exploring the responsive design features in UI5 for building Fiori apps that work across devices.

  474. Speaking at Mastering SAP Technologies

    I'm travelling to South Africa to give a keynote, a technical session and a hands-on workshop, on Fiori and UI5 topics.

  475. Fiori & UI5 Related Videos

    Collecting together an annotated list of my Fiori and UI5 related public videos.

  476. Morning Fiori Fix

    Investigating duplicate entries appearing in the Fiori App Reference Library.

  477. OpenUI5 at FOSDEM 2015

    Attending and presenting on OpenUI5 at FOSDEM 2015 in Brussels.

  478. Atom, Snippets, Tabs and CSON parsing

    Debugging a CSON parsing error in my UI5 snippets package for the Atom editor.

  479. Fiori App Data into a Spreadsheet? Challenge Accepted!

    Extracting data from the SAP Fiori App Reference Library into a Google Spreadsheet using OData and Apps Script.

  480. Running: 2014 in review, and some Clojure

    Reviewing my 2014 running stats and doing some simple data analysis in Clojure.

  481. DNA is still in our DNA

    Reflecting on how SAP's DNA of innovation persists even as technologies like Internet Explorer fade away.

  482. The inaugural SAP architect and developer summit

    Reflecting on my experience speaking at the inaugural SAP Architect and Developer Summit in Sydney.

  483. Creation & Reload of UI5 UIs in the Chrome Developer Console

    Demonstrating how to create and reload UI5 UIs directly in the Chrome Developer Console.

  484. Addressing emails

    Showing respect and courtesy by appropriate use of TO and CC.

  485. This Week in Fiori (2014-43)

    Covering week 43 of Fiori news with guest contributor Brenton O'Callaghan stepping in.

  486. This Week in Fiori (2014-42)

    Covering week 42 of Fiori news, the most significant week number.

  487. Speaking at the SAP Architect & Developer Summit

    Preparing to speak at the inaugural SAP Architect and Developer Summit in Sydney.

  488. This Week in Fiori (2014-40)

    Covering week 40 of Fiori news including the Fiori App Reference Library.

  489. This Week in Fiori (2014-39)

    Covering week 39 of Fiori news with links to stories and articles.

  490. This Week in Fiori (2014-38)

    Covering week 38 of Fiori news following SAP Inside Track Sheffield and a CodeJam in Liverpool.

  491. Scratching an itch - UI5 Icon Finder

    Building a UI5 Icon Finder app to search the vast library of icons available in UI5.

  492. This Week in Fiori (2014-36)

    Covering week 36 of Fiori news including openSAP courses and portal integration.

  493. This Week in Fiori (2014-35)

    Covering week 35 of Fiori news including catalogue design, TechEd previews and an all-SAP affair.

  494. This Week in Fiori (2014-34)

    Covering week 34 of Fiori news including documentation, extensibility, prototyping tools and workflow.

  495. This Week in Fiori (2014-33)

    Covering the SAP Fiori Launchpad architecture for developers, best practices for infrastructure, and the growing momentum behind Fiori adoption.

  496. This Week in Fiori (2014-32)

    Covering week 32 of Fiori news and TechEd-related content.

  497. This Week in Fiori (2014-31)

    Covering week 31 of Fiori news including the UX Explorer and OData-related content.

  498. This Week in Fiori (2014-30)

    Covering week 30 of Fiori news fresh from OSCON in Portland.

  499. Keyed vs Non-Keyed Root JSON Elements & UI5 Binding

    Exploring the difference between keyed and non-keyed root JSON elements in UI5 data binding.

  500. OpenUI5 Tutorial at OSCON 2014

    Presenting an OpenUI5 tutorial at OSCON 2014 in Portland with colleagues from SAP.

  501. This Week in Fiori (2014-29)

    Sharing Fiori links and commentary while heading to OSCON in Portland, including pointers to the open source foundations upon which UI5 is built.

  502. This Week in Fiori (2014-28)

    Covering week 28 of Fiori news including app analysis tools and technical content.

  503. Webinar and more - Understanding SAP Fiori

    Summarising our Understanding SAP Fiori webinar and Director's Cut deep dive sessions.

  504. This Week in Fiori (2014-27)

    Launching the This Week in Fiori series with commentary on the growing interest in SAP Fiori and UX.

  505. Understanding SAP Fiori Webinar - The Director's Cut

    Following up our Understanding SAP Fiori webinar with a deeper dive Director's Cut video.

  506. SAP Developer Advisory Board - Your Input!

    Asking the SAP developer community for input ahead of the Developer Advisory Board meeting.

  507. SAP Mentor Monday on UI5 - Links

    Collecting links from the public SAP Mentor Monday session on UI5 with Andreas Kunz.

  508. Paying IT Forward Links

    Sharing links from my SAP CodeTalk session on teaching kids computational thinking and coding.

  509. OpenUI5 CodeTalk Links

    Sharing links from my SAP CodeTalk session on OpenUI5 with Ian Thain.

  510. Small steps - OpenUI5 toolkit now in jsbin.com

    Celebrating the addition of the OpenUI5 toolkit to jsbin.com for easy code demos and snippets.

  511. Reaching Out

    Examining SAP's journey of reaching out to the wider developer community over four decades.

  512. Mocking up the Payroll Control Center Fiori App

    Mocking up a Fiori-style Payroll Control Center app to demonstrate how quickly such UIs can be built.

  513. The essentials - SAPUI5, OpenUI5 and Fiori

    An overview of SAPUI5, OpenUI5 and SAP Fiori, explaining what each is, how they relate to each other, and why they matter.

  514. Public SAP Mentor Monday 24 Mar 2014 - UI5 with Andreas Kunz

    Announcing a public SAP Mentor Monday session on UI5 with Andreas Kunz.

  515. M is for 'responsive'

    Exploring what responsive design means in the context of Fiori and the mobile revolution.

  516. Alt-K: Reading Notes

    Describing my workflow for saving articles to the Kindle with the Send to Kindle Chrome extension.

  517. XML Views and Resource Bundle Declarations

    Looking at how resource bundle declarations work in SAPUI5 XML views.

  518. UI5 XML Views - Another Example

    Providing another example of UI5 XML views with event handling and controller logic.

  519. Help us to help you - share your code

    Encouraging folks to share code via Gists and GitHub repos when asking for help with UI5 issues.

  520. Meta education - or teaching the teachers

    Exploring meta education and the importance of teaching teachers computational thinking skills.

  521. Quick hack: Calendar Inviter

    Building a quick Google Apps Script hack to sync calendar events across multiple organisational calendars.

  522. Mobile Dev Course W3U3 Rewrite - XML Views - An Analysis

    Analysing the differences between JavaScript and XML view implementations in my W3U3 rewrite.

  523. Custom Sorting and Grouping

    Learning how to control the order of groups in a sorted list using the sorter function rather than the grouper.

  524. SAP UK & Ireland User Group Conference - Demo Jam!

    Recounting how I stepped in at the last minute to compete in the Demo Jam at the SAP UK and Ireland User Group Conference, building a Fiori app live on stage.

  525. CodeTalk - SAPUI5 and SAP Fiori

    A two-part CodeTalk video interview covering SAPUI5 and SAP Fiori, from general concepts and architecture through to hands-on code and demos.

  526. Mobile Dev Course W3U3 Rewrite - XML Views - An Intro

    Introducing the XML views branch of my W3U3 rewrite, rebuilding the JavaScript views in XML.

  527. Mobile Dev Course W3U3 Rewrite - ProductList, ProductDetail and SupplierDetail

    Explaining the changes to the ProductList, ProductDetail and SupplierDetail views in my W3U3 rewrite.

  528. Mobile Dev Course W3U3 Rewrite - App and Login

    Explaining what I changed in the App and Login views and controllers in my rewrite of the open.sap.com mobile dev course sample SAPUI5 app.

  529. Mobile Dev Course W3U3 Rewrite - Index and Structure

    Explaining my changes to the index.html file and general app structure in my W3U3 rewrite.

  530. Mobile Dev Course W3U3 Rewrite - Intro

    Introducing my rewrite of the open.sap.com mobile course sample SAPUI5 app to fix some fundamental issues.

  531. Building SAP Fiori-like UIs with SAPUI5

    Previewing my SAP TechEd sessions on building SAP Fiori-like UIs with SAPUI5.

  532. SheetAsJSON - Google Spreadsheet Data as JSON

    Explaining how to expose Google spreadsheet data as JSON via HTTP using Google Apps Script.

  533. An Amazing 36 Hours at SAP Labs Israel

    Recounting a whirlwind 36 hours visiting the developer engine that is SAP Labs Israel.

  534. Engaging the Next Generation

    Reflecting on my involvement with Young Rewired State and engaging the next generation of coders.

  535. #YRS2013 Hacks on Github

    Celebrating the use of GitHub and open source at the Young Rewired State Festival of Code weekend.

  536. Happy Birthday SCN, Old Friend

    Reflecting on ten years of the SAP Community Network and my involvement from the very beginning.

  537. Simple SAPUI5 Chrome icon for lazy developers like me

    Creating a simple Chrome hosted app icon to quickly navigate to the SAPUI5 Developer Center on SCN.

  538. CodeClub Thoughts

    Sharing thoughts and experiences from leading a CodeClub at my local primary school.

  539. Review of Dark Reserve Nr 3 from Lovibonds

    Reviewing Dark Reserve Nr 3 from the Lovibonds brewery.

  540. Functional Python - Itertools Exploration

    Exploring functional programming concepts in Python through itertools as part of my ongoing 30-day challenges.

  541. Our computational future

    Making the case for teaching computational thinking and coding skills to the next generation in the UK.

  542. 30 Day Challenge: No Beer!

    Embarking on my February 30-day challenge of no beer after successfully completing a month without Twitter.

  543. Getting Started with SAPUI5: Alternative Guide

    Putting together an alternative getting started guide for SAPUI5 focused on portability and independence.

  544. Public Github repo sapui5bin available

    Making my growing collection of runnable SAPUI5 snippets available as a public GitHub repo.

  545. Jump to Shell Workset Item from URL

    Discovering how to jump to specific SAP Shell workset items from a URL.

  546. 30 Days Challenges

    Starting a series of 30-day challenges inspired by Matt Cutts as an alternative to New Year's resolutions.

  547. Review of Fourth Dementia Old Ale from Kuhnhenn Brewing Company

    Reviewing Fourth Dementia Old Ale from Kuhnhenn Brewing Company.

  548. Bind Paginator to model?

    Experimenting with binding a SAPUI5 Paginator control to a model for automatic page calculation.

  549. CodeClub and becoming a STEM Ambassador

    Volunteering with CodeClub and becoming a STEM Ambassador to help kids learn to code.

  550. The Silent Club and Recharging Alone

    Reflecting on the Silent Club concept and the importance of recharging alone as an introvert.

  551. OData Everywhere

    Musings on the Open Data Protocol, SAP NetWeaver Gateway, and the importance of both.

  552. Blog It Forward - DJ Adams

    Taking part in the Blog It Forward community challenge on SCN.

  553. Review of Norwegian Wood from Haandbryggeriet

    Reviewing Norwegian Wood, a smoked beer from Norway's Haandbryggeriet, at Port Street Beer House.

  554. Recent Interests

    Visualising my recent blogging interests with a Wordle word cloud.

  555. Serial interest in the Raspberry Pi

    Attending the Manchester Raspberry Jam and connecting a vintage Wyse terminal to a Raspberry Pi.

  556. Gateway metadata cache check - always abap_true?

    Debugging the Gateway metadata caching mechanism and finding a potential issue.

  557. SAPUI5 - the future direction of SAP UI development?

    Looking at SAPUI5 as the future direction of SAP UI development.

  558. Two tools for Gateway trial host nplhost

    Recommending two useful tools, multitail and screen, for working with the SAP NetWeaver Gateway trial system.

  559. On Enterprise Geeks Podcast

    Appearing on the Enterprise Geeks podcast after reconnecting at SAP DKOM.

  560. Firebase and SAPUI5

    Exploring Firebase as a backend-as-a-service in the context of SAPUI5 and realtime data.

  561. The Developer Connection: Connect Like Never Before

    Rediscovering SAP's Developer Connection at DKOM and the renewed focus on developers.

  562. SAPUI5 Powered SCN Forum Finder

    Building a SAPUI5-powered forum finder to help locate the old SDN forums on the new SCN platform.

  563. New Omniversity Course Video!

    Releasing a new video for my Web Programming with SAP's Internet Communication Framework course.

  564. Review of Red Rice Ale from Hitachino Nest

    Reviewing Red Rice Ale from Japan's Kiuchi brewery at Port Street Beer House.

  565. SAPUI5 says "Hello OData" to NetWeaver Gateway

    Exploring the newly released SAPUI5 beta and connecting it to NetWeaver Gateway via OData.

  566. Making OData from SAP accessible with the ICM's help

    Using the SAP Internet Communication Manager to make OData from NetWeaver Gateway more accessible.

  567. SAP ICF course marketing: video!

    Creating a marketing video for my SAP ICF course at the Omniversity.

  568. On the Information Diet

    Reflecting on the movement to consume less information and produce more.

  569. The Developer Renaissance

    Interviewing SAP's Aiaz Kazi on the developer renaissance at SAP TechEd in Madrid.

  570. HTML5 @ SAP

    Attending the HTML5 at SAP session at TechEd and seeing SAP's embrace of open standards.

  571. SAP Developer Center

    Exploring the SAP Developer Center booth at SAP TechEd Madrid 2011.

  572. Movember - please donate!

    Taking part in Movember and asking for donations to raise awareness of men's health.

  573. Web Programming with SAP's ICF: new course dates

    Announcing new dates for my Omniversity course on Web Programming with SAP's Internet Communication Framework.

  574. Moving on ... to Bluefin Solutions

    Moving on from contracting to joining Bluefin Solutions.

  575. Review of Milk Stout from Left Handed Brewing Co

    Reviewing Milk Stout from Left Hand Brewing Co at Port Street Beer House.

  576. Reading List Mark 2 - Part 5

    Wrapping up the reading list app series by putting it all together and using the User Interface services.

  577. Reading List Mark 2 - Part 4

    Continuing the reading list app series, covering synchronisation between the spreadsheet and content sources.

  578. Reading List Mark 2 - Part 3

    Continuing the reading list app series, covering the UrlFetch Services for interacting with external APIs.

  579. Reading List Mark 2 - Part 2

    Continuing the reading list app series, covering the Tasks API for retrieving and inserting tasklists.

  580. Reading List Mark 2 - Part 1

    Introducing a reading list app built with Google Apps Script to demonstrate various API integrations.

  581. Automated email-to-task mechanism with Google Apps Script

    Looking at an example Google Apps Script that automates email-to-task conversion.

  582. Ad-hoc Data Workflows with Google Apps Script

    Presenting on building ad-hoc data workflows with Google Apps Script at the Manchester GTUG.

  583. Stand steady on the shoulders of giants

    Making the case for attending my Omniversity course on Web Programming with SAP's Internet Communication Framework.

  584. Review of Torpedo from Sierra Nevada

    Reviewing Torpedo IPA from Sierra Nevada at Port Street Beer House's American Beer Festival.

  585. Beer review: Dark Star's Saison

    Reviewing Dark Star's Saison cask beer at Port Street Beer House.

  586. SOA scaffolding and development architects

    Reflecting on where SOA stands today and the role of development architects in service orientation.

  587. Review of Saison from Dark Star

    Reviewing Saison from Dark Star at Port Street Beer House in Manchester.

  588. Danger! Graduate Conveyor-belt!

    Responding to John Appleby's piece on university degrees and the IT industry with thoughts on education and learning.

  589. JSON and Other Animals - talk at Manchester jQuery Meetup

    Presenting on JSON, AJAX and JSONP at the Manchester jQuery Meetup at MadLab.

  590. Gmail Contextual Gadgets - talk at Manchester GTUG

    Giving a talk on Gmail Contextual Gadgets at the Manchester Google Technology User Group.

  591. My browser A-Z

    Listing my browser A-Z, the URLs that appear on a single letter press based on past browsing.

  592. The past and future of SAP integration: guest Bluefin blog post

    I wrote a guest blog post on the Bluefin Solutions website, about the Project Gateway.

  593. Project Gateway. A call to arms. Or at least to data.

    This was a guest blog post on Bluefin Solutions website which I wrote to herald a major turning point in SAP software's integration trajectory.

  594. Hacking the Delicious extension for Chrome

    Hacking the Delicious bookmarking extension for Chrome to fix some annoyances after switching from Firefox.

  595. Google Visualization API: Manchester GTUG Talk

    Presenting on the Google Visualization API at the Manchester Google Technology User Group meetup.

  596. Not your father's SAP

    Some thoughts following the Innovation Weekend 2010 at SAP.

  597. Getting started with Gmail Contextual Gadgets

    Getting started with Gmail contextual gadgets and exploring their developer potential.

  598. Scratching an itch - Magic The Gathering card info

    Scratching an itch by building a quick tool to look up Magic The Gathering card information.

  599. REpresentational State Transfer (REST) and SAP

    Exploring how REST as an architectural style applies to SAP integration scenarios.

  600. Tech skills chat with JonERP - a follow-on story

    How I was inspired to read and learn more.

  601. REST orientation - Controlling access to resources

    Auth with respect to the alternative dispatcher layer in ABAP.

  602. A new REST handler / dispatcher for the ICF

    One of the best underlying mechanisms to be introduced into the Basis / NetWeaver stack in the past few years is the Internet Communication Framework (ICF), which is a collection of configuration, interfaces, classes and a core set of processes that allow us to build HTTP applications directly inside SAP.

  603. Mainframes and the cloud - everything old is new again

    Drawing parallels between mainframe computing and the cloud, noting how everything old is new again.

  604. SAP and Google Wave - Conversation Augmentation

    Demonstrating integration between Google Wave and SAP, inspired by the Dashboard project from six years earlier.

  605. Book review - SAP Business ONE Implementation

    Reviewing the SAP Business ONE Implementation book by Wolfgang Niefert.

  606. One way of dealing with blogtheft from SDN - through images

    Using image-based techniques to deal with content being stolen from SDN.

  607. Dealing with "#blogtheft" from SAP's Developer Network

    Addressing the blogtheft problem where content was being lifted wholesale from SAP's Developer Network.

  608. Command lines of the future, and simplicity of integration

    Thinking about chat-style interfaces as command lines of the future and their implications for integration.

  609. Coffeeshop screencast: HTTP conneg, resource representations and JSON

    Showing HTTP content negotiation, resource representations and JSON support in coffeeshop.

  610. 2nd coffeeshop REST/HTTP screencast

    Recording a second coffeeshop screencast highlighting its REST-orientated HTTP-based pubsub nature.

  611. Google Wave, XMPP and complexity

    Considering the complexity of Google Wave and XMPP versus the incremental approach of the web.

  612. Webhooks postbin example for Coffeeshop

    Demonstrating webhooks with coffeeshop using the PostBin developer utility.

  613. First coffeeshop demo screencast

    Recording a screencast demonstrating some of the basic features of my coffeeshop pubsub project.

  614. 'Coffeeshop' - lightweight HTTP-based pubsub

    About a lightweight, REST-orientated HTTP-based publish/subscribe implementation that I’ve been working on for the last few days.

  615. Information vs Behaviour

    Architectures, axioms and ROA vs SOA.

  616. A return to the SDN community, and a touch of Javascript

    Returning to the SDN community after six years and reflecting on how it has grown.

  617. Tarpipe REST connector in 5 minutes

    Demonstrating the new Tarpipe REST connector with a quick five-minute example.

  618. Twitter's success

    Thoughts on messaging, microblogging, and Twitter's success.

  619. Analysing CV searches with Delicious

    Analysing search terms used to find my online CV using Perl and Delicious.

  620. SAP everywhere!

    Noticing how SAP has become ubiquitous in bookstores and beyond since the early days.

  621. An HTTP connector for Tarpipe: 'tarbridge'

    Building tarbridge, an HTTP connector for Tarpipe that enables POST requests to arbitrary URLs.

  622. tarpipe.com - Programming 2.0?

    Exploring whether tarpipe.com represents an early example of a Programming 2.0 concept.

  623. Old feed URLs fixed with a bit of mod_rewrite voodoo

    Fixing old feed URLs with some Apache mod_rewrite rules to redirect feed bots to the right place.

  624. Back from Real Life

    I’m back online, after an eXtended Away in Real Life.

  625. OssNoteFix script updated for Greasemonkey 0.6.4 and Firefox 1.5

    Updating my OssNoteFix Greasemonkey script to work with newer versions of Greasemonkey and Firefox.

  626. Java and Gosling's FUD - madness or desperation?

    Questioning James Gosling's FUD about dynamic languages in the context of Java's declining dominance.

  627. SAP and Open Source: the debate continues

    Continuing the debate on SAP and open source following my earlier analysis and letter.

  628. Acorn Atom and my start in computing

    Reminiscing about how I got into computing, starting with the Acorn Atom.

  629. SAP and Open Source: an analysis and letter to SAP and Shai

    Analysing SAP's position on open source and writing an open letter to SAP and Shai Agassi.

  630. MoonOverFailsworth

    Capturing a photo of an enormous moon rising over Failsworth.

  631. Whither SAP?

    I’ve been thinking a lot recently about where SAP is going and what SAP is doing today, especially in the light of where it went and what it did in the past. To be honest, the thinking has been triggered by frustration at the nuts and bolts of SAP technical matters, particularly in the area of service support and basis work.

  632. SDN, Blogging, and Planet SAP

    In May I was approached by a chap at SAP in Walldorf who wanted to ask me some questions on blogging (I have a blog over on the SAP Developer Network) for an article he was writing for an SAP-internal magazine.

  633. The SAP developer community 10 years ago

    On the early years of the SAP community online.

  634. Turnkey MVS 3.8J on Hercules S/370 Screenshot

    Big iron and retrocomputing.

  635. SAP: temporary loss of touch with reality?

    Responding to Shai Agassi's questionable views on open source software at Sapphire in Boston.

  636. Hacking the SAP service portal to make OSS notes better

    Deploying Greasemonkey to fix a long standing issue with OSS Notes at SAP.

  637. Ubuntu? Thanks. But no thanks.

    Lots of people seem to be very impressed with Ubuntu, the slick new Linux distro based on Debian, running Gnome.

  638. Europe, SAP, and two-way conferences

    It’s the end of the week that saw the SDN Meets Labs down in Walldorf.

  639. Flickr Pro from Robert

    I’m going to have to think of ways to make use of the extra bandwidth and picture storage capabilities, aren’t I?

  640. SDN Meets Labs

    Rain. Lots of it. And I drove through it all this morning, all the way down the A61, to get to SAP University in Rot, near Walldorf.

  641. SDN Meets Labs gets underway at SAP University

    The SDN Meets Labs at Walldorf-Rot gets underway at Walldorf-Rot.

  642. Muscle cars

    Admiring some monster-engined muscle cars at the Oxford services on the M40.

  643. An overcorrection too far?

    Norman Walsh gives up ‘wrestling his way through the arcana of WSDL’.

  644. Postcode bookmarklet

    We’ve been spending time recently looking at property in the North West.

  645. Weblog happy in new home - note new URLs!

    Cool URIs don't change ... much.

  646. Ralphm on sjabber

    Digging into sjabber's source.

  647. Honest application requirements

    An unusual "user story".

  648. Blosxom entries into MT

    After setting up this blog, it was only natural to bring across my earlier blog posts that were previously served with Blosxom.

  649. A fresh start

    The perils and joys of self-hosting at a colo.

  650. (Mini) Installfest in the SDN clubhouse at TechEd

    Running a mini installfest with the latest WAS 6.40 demo system on a small Linux server at SAP TechEd.

  651. Photos from SAP TechEd Munich

    The third weblog in two days … what’s going on? Well, Mark is a hard taskmaster, obviously 🙂

  652. The meaning of LIFETIME_RC

    Last week, during some preparation for my talk at TechEd on Thursday this week, I’d been wondering about something in the ICF that hadn’t seemed quite right.

  653. SAP TechEd first day - notes from Munich

    Well, after a nightmare getting here (V-Bird, the airline I was booked with, went bust) I’m now in Munich at a decidedly disconnected TechEd 04 (more on the disconnected misery later).

  654. SAP TechEd here I come ... with session slides!

    SAP TechEd is looming large, and this year it's in Munich. (If you’re not in Europe, then SAP are holding TechEd events in Bangalore, Tokyo, and San Diego too).

  655. The integration irony of SAP's technology directions

    I’ve finally realised what it is that’s been bugging me about the new arena of SAP technology.

  656. The Curious Incident Of The Dog In The Night-Time

    I bought three books at Manchester airport yesterday.

  657. A little taste of SAP at EuroFoo

    Presenting a lightning talk on SAP at the EuroFoo mini-conference in Enschede.

  658. SDN Meetup in Walldorf - a summary

    Well, 24 hours (almost to the minute) have passed since I got off the train at Wiesloch-Walldorf station yesterday.

  659. SDN Meetup in Walldorf - pictures

    Sharing pictures from the SDN Meetup in Walldorf.

  660. TechEd talk winners - congrats

    Congratulations to the three TechEd talk winners Luke, Jayakumar and Andreas.

  661. Forget SOAP - build real web services with the ICF

    I don’t like getting into a lather when it comes to data and function integration. Rather than using SOAP, I prefer real web services, built with HTTP.

  662. Real Web Services with REST and ICF

    This piece has become somewhat famous (or infamous) in SAP tech circles, for the approach it took and the claims it made. I'm happy to say that REST won out and that those that tried to denounce me ... failed :-)

  663. NW4, OSS1 and logon group selection for OSS

    Digging into logon group selection.

  664. SAP at JAX 2004

    A brief report on JAX 2004.

  665. WAS 6.40 testdrive for Linux is here!

    Phew. What a day yesterday at the world’s biggest IT fair.

  666. Successful installation of EP plugin into testdrive WAS 6.10 system

    I spent most of yesterday in the kitchen, my favourite place.

  667. Tim O'Reilly and the three 'C's

    Well, I made it to FOSDEM this morning with time to spare.

  668. FOSDEM, and small OSS Notes Browser Hack

    Tomorrow morning I'm off to Brussels for FOSDEM - the Free and Open Source Software Developers' Meeting.

  669. FOSDEM and Brussels, here I come!

    I’ve been umming and arring over conferences this year.

  670. Hawo's Queen of Grain Mills

    I've been baking bread now for quite a while now. The bread baking bug first got ahold of me when visiting friends. They had a bread making machine – something that you put all the basic ingredients into, hit a button, and presto. Naturally we bought one soon after, and I was, well, "hooked".

  671. Hello, 2004

    2004 is here. Neues Spiel, neues Glück.

  672. Evaluation WAS 6.40 on Linux - top reason for attending CeBIT 2004

    The prospect of SAP on Linux at CeBIT.

  673. Food for thought: LDBs and ABAP Objects

    Musing on the relationship between Logical Databases and ABAP Objects while debugging output determination.

  674. BSP: Mangled URL Decoder

    A quick dive into the details of BSP URLs.

  675. SAP TechEd - Collaborative notes

    I’m off to SAP TechEd this week in Basel.

  676. Dashboard as extension to R/3 and SAPGUI client

    How do your users work with SAP data? Exclusively through SAPGUI or with other desktop apps too? If it’s the latter, read on.

  677. Plums and the antithesis of technology

    I haven’t been online much recently.

  678. Improving the OSS note experience

    How can we make this key service less unpleasant to use?

  679. SAP InfoTag on Web Application Server

    SAP are running an Infotag on the Web Application Server in early September.

  680. SAP talk at OSCON, and RSS

    On SAP, open source, and multiple uses for RSS.

  681. Google Pocket Guide out now

    My new book for O'Reilly is out.

  682. Another great OSCON

    Reflecting on another Open Source Convention.

  683. Thanks, Randal

    Relaxing in an 80's arcade at OSCON.

  684. Dashboard, a compelling articulation for realtime contextual information

    Miguel de Icaza and Nat Friedman were keynoting at OSCON this morning.

  685. SAP and Open Source BOF at OSCON

    A note on the Birds Of A Feather session at OSCON on the topic of SAP and Open Source, at OSCON 2003.

  686. Bittersweet

    On each occasion I’ve travelled to the USA, either on business or for pleasure, I’ve entered the country with a rather bitter taste in my mouth.

  687. Thinking vs doing

    In the past, I’ve mentioned to friends some of the thinking I’ve had about the Semantic Web, RDF, and related stuff (FOAF, RSS, and so on).

  688. Some ramblings on URIs and identity

    Coming back from a short break from the tech world recently, I started to reacquaint myself with FOAF and RDF, amongst other things.

  689. SAP stuff at OSCON

    My partner-in-(code)-crime Piers Harding and I are speaking at this year’s OSCON (Open Source Convention).

  690. The SAP/MySQL Partnership

    I keep hearing reports that the recent announcement of cooperation between SAP AG and MySQL AB has been making the community unhappy.

  691. Speaking at OSCON 2003

    Always an honour and a privilege.

  692. "A brilliant literary mash-up"...

    The fusion of Hogwarts and Molesworth.

  693. Weblogs and Wikis - Blurring the Boundaries

    More on the crossover between blogging and wikis.

  694. New Blosxom plugin 'submission'

    A generic blogging mechanism for accepting content POSTed to it.

  695. 'Conneg' and the duality of weblogs

    Philosophy triggered by the lowly but essential connection negotiation aspect of HTTP.

  696. Tiki parser for MoinMoin

    Embedding the Tiki language into the MoinMoin wiki.

  697. Blosxom 2.0 Beta1

    Looking at the latest release of the blogging software that I use.

  698. RSS aggregators and user-agent information for Blagg

    Tool reuse a la Unix philosophy, and more on building out the future in tiny steps.

  699. Tinkering with RSS and NNTP

    The beauty of open standards is that they can be adopted, remixed and combined.

  700. Your wishlist in 'consumable' XML

    Introducing a new experimental Perl module.

  701. Asleep in 2002

    Amazon does seem to have XML based data available after all.

  702. The fragility of retro-engineering

    Having to modify my allconsuming scripts because of differences between amazon.co.uk and amazon.com data.

  703. Transferring my Amazon wishlist to AllConsuming.net

    Scripting to the rescue, as always.

  704. Presentations, Wikis, and Site Navigation

    Why build something when there's already a standard to embrace?

  705. Content-Type and Blosxom's RSS

    The perils of unescaped content in feeds.

  706. Wisdom, diplomacy, or serendipity?

    On the architectural style(s) of allcosuming.net's API.

  707. The universal canvas and RSS apps

    Thoughts on the applicability and utility of the format.

  708. The disruptive engineering spectrum, and "booktalk", an AllConsuming app

    Creating an experimental service based on existing mechanisms.

  709. Creating the "Entry index"

    More on building out how my blog looks.

  710. A new year and a new approach

    Taking a fresh, less cluttered approach to the website and blog.

  711. Startups and software patents

    Dave W points to Strangeberry, a startup that are doing a Java rendition of Rendevous.

  712. For REST, read 'Architectural Style'

    In the swirling mass of memes surrounding web services it’s sometimes easy to forget that REST is an architectural style, an approach, rather than something that you install or debug.

  713. "Assaults on the Internet's end-to-end-architecture"

    What can and should we do about spam?

  714. Ben's RSS book

    A new book on RSS from Ben Hammersley.

  715. RESTifying RT

    Some notes on providing a RESTful API for Request Tracker.

  716. 'Practical RDF' book up for public review

    Shelley Powers' new book.

  717. Notes to self: What should the rdf:about point to?

    If nothing else, RSS 1.0 is a great source of contemplation and wondering. This morning, I’ve been considering the thoughts surrounding the rdf:about attribute in the channel element.

  718. A moment of clarity: The significance of RSS 1.0 as an RDF application

    It's to do with the emphasis on RDF rather than XML, in RSS.

  719. The case of the missing rdf:Description

    Investigating why an rdf:Description element can be omitted from certain RDF serialisations.

  720. More thoughts to ponder

    Here are two or three thoughtbites that I’ve come across over the past few days and that have stayed with me. I just thought I’d share them here as it’s the weekend and often a good time to think about things.

  721. XML Scripting, data manipulation, and RDF

    Can there be native support for XML as a data type?

  722. Moving from description to content:encoded in my RSS 1.0 feed

    Using the mod_content module of RSS 1.0.

  723. From RSS 0.91 to 1.0

    Incantations to progress to RSS 1.0.

  724. The RDF in RSS

    Digging into the real truth about the RDF in RSS.

  725. Moving between Mozilla tabs with the keyboard

    An answer to my question on keyboard controllable Mozilal features.

  726. Mozilla "Bookmark This Group of Tabs"

    Improving the browsing experience one feature at a time.

  727. REST, Google, and idempotency

    Pondering the apparent conundrum of REST, Google and idempotency that Sam Ruby presented to Mark Baker.

  728. Cacheing on XSLT service

    More on the Mozilla sidebar experiments.

  729. Sidebars, Mozilla, RSS: old and new

    RSS, RDF, XUL, XSLT and more.

  730. You know you're getting old ...

    Looking back on this year's OSCON.

  731. The OS tables are turning...

    The origins of one of my favourite phrases "Does not work on Windows".

  732. Just finished re-reading: The Player Of Games (Iain M Banks)

    Some thoughts on The Culture.

  733. The mist is clearing ...

    On my continuing quest to grok REST.

  734. From REST to URIs, the Semantic Web, RDF, and FOAF

    Protocols and formats making up the semantic web.

  735. The 80/20 of HTTP

    Musing on how HTTP is used in the main.

  736. Reflecting weblogs.com 'ping's with SOAP, Jabber, and Pubsub

    More on building out the weblog-o-sphere infrastructure.

  737. Programming Jabber review

    A positive review of my O'Reilly book.

  738. Accessibility and Blosxom

    Extending my blogging engine for accessibility.

  739. A change and a rest

    Back recharged from holiday.

  740. 'Blosmail' - add and maintain your blog entries via email

    Experimenting with Blosxom editing via a different medium.

  741. Standing on the shoulders ... Exploring Weblog Neighbourhoods with Blogdex

    Inspired by Mark and Dave, I’ve been doing a bit of neighbourhood exploration hacking of my own.

  742. Small Blagg mod to enable custom formatting of 'blaggregated' items

    An unofficial modification to Blagg.

  743. Changed link tags

    More work on RSS, metadata and discovery.

  744. HTML link tag for Blogroll

    Social network scripting and blog rolls.

  745. Collapse/Expand feature for my Blaggregated display

    Extending Blagg and related features.

  746. Extreme Computing 2002

    Going to the Festival of Inappropriate Technology.

  747. RSS's underlying structure, and meta-RSS.

    I’ve been pondering the nature of RSS, the lightweight syndication and feed format which is a heavy contender for the most talked-about XML format these days (uh, I suppose this post goes some way to help the cause too :-).

  748. HTML LINK to RSS source

    Continuing the build-out of weblog based mechanisms.

  749. Top tip

    On falling down the stairs.

  750. ETag-enabled wget

    Adding ETag awareness to the venerable wget utility.

  751. More thoughts on HTTP, Email, and Jabber

    On HTTP headers and queueing architectures.

  752. "Web^H^H^HInternet Services"? Some Ramblings.

    I’ve been pondering the term “Web Services”. While I completely understand and agree with all the reasonings behind the term (the ‘original’ services were accessible via web clients, HTTP is the underlying and ubiquitous transport, blah blah blah), I’m wondering whether “Web Services” is the best term to use.

  753. The Panopticon

    Extending the Panopticon experiment with XML messaging via Jabber.

  754. Jabberconf Blaggplug version 0+1b

    Updating the Jabber conference plugin for Blagg (the Blosxom RSS aggregator).

  755. (Jabber-)Browsing the Panopticon data

    More on extending the Panopticon experiment.

  756. Amphetadesk Links

    More on feeds, subscriptions and aggregations.

  757. Subscription from Radio

    Maintaining feed metadata.

  758. Mr 80-Percent

    Reflecting on the 80-percent approach to work and why working fewer hours can mean getting more done.

  759. Blaggplug: jabberconf

    Aggregation and publish/subscribe.

  760. YARM: Yet Another Referers Mechanism

    Referers, backlinks, and the Unix command line.

  761. One small step ... one giant leap ...

    Calling remote functions over Jabber.

  762. Calendar code

    The calendar script for my sidebar.

  763. Bring on the SSI

    Server Side Includes and Blosxom.

  764. Blosxom vs the world

    The choice and decision to use specific blogging software.

  765. Blog software review

    More on blogging software.

  766. community(disagreement + debate) = inspiration

    The debate between SOAP and REST.

  767. "Blog Locally, Publish Globally"

    On the enduring pattern of local control but global reach.

  768. Other side of the coin: 5335 now resurrected

    RSS, Radio Userland, and redirectors.

  769. Original Peerkat-based weblog back up for reference

    More on Peerkat, a data syndication aggregator.

  770. Coffee Mugs and weblog interop

    Experimenting with Peerkat, feeds and Blosxom.

  771. Cross pollination and blossoming of scripts

    On the growing Blosxom ecosphere.

  772. My bookmarks

    Scripting with bookmarks.

  773. Off with the (relatively) old, on with the new

    More on Blosxom, and a fix to our colocated server.

  774. Interview on jabber.org

    A transcript of my interview on jabber.org.

  775. Hello Blosxom

    A move to the Blosxom blogging software.

  776. Bot window as command line of the future

    Musing on doing more from within the chatbot prompt.

  777. FOSDEM interview

    This post is a transcript of an interview by Raphaël Bauduin for FOSDEM.

  778. What is a Jabber client?

    "A rose is a rose, by any other name." But is the same true for a Jabber client? I don't think so.