DJ Adams

Blog posts tagged "cap"

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

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

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

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

  4. Modules, modularity & reuse in CDS models

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

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

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

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

  8. Some ramblings on simple CDS modelling with CDL

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

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

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

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

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

  13. CDS source formatting and readability

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

  14. Upcoming talks in autumn 2025

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

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

  16. A reCAP intro to the cds REPL

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

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

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

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

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

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

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

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

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

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

  26. CAP Node.js Plugins

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

  27. TASC Notes - Part 6

  28. TASC Notes - Part 5

  29. TASC Notes - Part 4

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

  31. The Art and Science of CAP

  32. TASC Notes - Part 3

  33. TASC Notes - Part 2

  34. Flattening the hierarchy with mixins

  35. Five reasons to use CAP

  36. Separating concerns and focusing on the important stuff

  37. Restricting access via facets with masked elements

  38. Keeping things simple in domain modelling with CDS

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

  40. TASC Notes - Part 1

  41. Automatic validation in OData and REST calls with CAP

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

  43. Digging into CSN diffs for CDS models

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

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

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

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

  48. Running non-production CAP services in CF

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

  50. Improve your CAP dev container shell prompt

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

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

  53. CAP, CORS and custom headers

  54. ISO content for common CAP types

  55. Successful double CodeJam in Wroclaw and Warsaw

  56. Developing CAP in containers - three ways

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

  58. SAP CodeJam on Service Integration with CAP in Brescia

  59. A deep dive into OData and CDS annotations

  60. SAP CodeJam on Service Integration with CAP in Utrecht

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

  62. CAP is important because it's not important

  63. Tech Aloud podcast - an introduction

  64. Monday morning thoughts: growth is upwards

See all tags.