DJ Adams

Blog posts tagged "cds"

  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. CDS expressions in CAP - notes on Part 6

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

  3. CDS expressions in CAP - notes on Part 5

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

  4. CDS expressions in CAP - notes on Part 4

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

  5. CDS expressions in CAP - notes on Part 3

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

  6. CDS expressions in CAP - notes on Part 2

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

  7. CDS expressions in CAP - notes on Part 1

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

  8. Genres, cuids and a bit of AWK

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

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

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

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

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

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

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

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

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

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

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

  18. Modules, modularity & reuse in CDS models

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

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

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

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

  22. Some ramblings on simple CDS modelling with CDL

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

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

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

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

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

  27. CDS source formatting and readability

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

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

  29. A reCAP intro to the cds REPL

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

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

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

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

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

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

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

  36. CAP Node.js Plugins

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

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

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

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

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

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

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

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

  44. Flattening the hierarchy with mixins

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

  45. Separating concerns and focusing on the important stuff

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

  46. Restricting access via facets with masked elements

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

  47. Keeping things simple in domain modelling with CDS

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

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

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

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

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

  52. Digging into CSN diffs for CDS models

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

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

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

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

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

  55. ISO content for common CAP types

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

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

  57. Boosting tutorial UX with dev containers part 3 - containers into action

    Putting everything together by connecting VS Code to the dev container and running through the first steps of the CAP tutorial.

  58. Computed field example in CAP

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

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

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

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

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

See all tags.