DJ Adams

Blog posts tagged "cap"

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. CDS expressions in CAP - notes on Part 6

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

  9. CDS expressions in CAP - notes on Part 5

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

  10. CDS expressions in CAP - notes on Part 4

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

  11. CDS expressions in CAP - notes on Part 3

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

  12. CDS expressions in CAP - notes on Part 2

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

  13. CDS expressions in CAP - notes on Part 1

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

  14. Genres, cuids and a bit of AWK

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

  15. 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.

  16. 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.

  17. 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.

  18. 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.

  19. 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.

  20. 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.

  21. 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.

  22. 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.

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

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

  24. Modules, modularity & reuse in CDS models

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

  25. 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.

  26. 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.

  27. 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.

  28. Some ramblings on simple CDS modelling with CDL

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

  29. 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.

  30. 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.

  31. 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.

  32. 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.

  33. CDS source formatting and readability

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

  34. Upcoming talks in autumn 2025

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

  35. 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.

  36. A reCAP intro to the cds REPL

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

  37. 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.

  38. 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.

  39. 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.

  40. 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.

  41. TASC Notes - Part 9

    These are the notes summarising what was covered in The Art and Science of CAP part 9, one episode in a mini series with Daniel Hutzel to explore the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  42. TASC Notes - Part 8

    These are the notes summarising what was covered in The Art and Science of CAP part 8, one episode in a mini series with Daniel Hutzel to explore the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  43. TASC Notes - Part 7

    These are the notes summarising what was covered in The Art and Science of CAP part 7, one episode in a mini series with Daniel Hutzel to explore the philosophy, the background, the technology history and layers that support and inform the SAP Cloud Application Programming Model.

  44. 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.

  45. 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.

  46. CAP Node.js Plugins

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

  47. TASC Notes - Part 6

  48. TASC Notes - Part 5

  49. TASC Notes - Part 4

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

  51. The Art and Science of CAP

  52. TASC Notes - Part 3

  53. TASC Notes - Part 2

  54. Flattening the hierarchy with mixins

  55. Five reasons to use CAP

  56. Separating concerns and focusing on the important stuff

  57. Restricting access via facets with masked elements

  58. Keeping things simple in domain modelling with CDS

  59. 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.

  60. TASC Notes - Part 1

  61. Automatic validation in OData and REST calls with CAP

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

  63. Digging into CSN diffs for CDS models

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

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

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

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

  68. Running non-production CAP services in CF

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

  70. Improve your CAP dev container shell prompt

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

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

  73. CAP, CORS and custom headers

  74. ISO content for common CAP types

  75. Successful double CodeJam in Wroclaw and Warsaw

  76. Developing CAP in containers - three ways

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

  78. SAP CodeJam on Service Integration with CAP in Brescia

  79. A deep dive into OData and CDS annotations

  80. SAP CodeJam on Service Integration with CAP in Utrecht

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

  82. CAP is important because it's not important

  83. Tech Aloud podcast - an introduction

  84. 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.

See all tags.