DJ Adams

Blog posts tagged "learning"

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

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

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

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

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

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

  7. Highest value in JS - different ways

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

  8. Devtoberfest - the best developer prep for SAP TechEd

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

  9. Bash shell expansion inside double quotes

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

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

  11. Learning from community solutions on Exercism - part 3

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

  12. Learning from community solutions on Exercism - part 2

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

  13. Learning from community solutions on Exercism - part 1

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

  14. Learning from exploring a question on jq

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

  15. Bash notes 3

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

  16. Bash notes 2

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

  17. Bash notes

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

  18. Exercism and jq

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

  19. Truncation and neat terminal output

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

  20. Controlling Chrome from the CLI

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

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

  22. Embracing jq and JSON

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

  23. Sourcing vs executing in Bash

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

  24. Using functions more

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

  25. Improving shell fu with practice

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

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

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

  28. Today's TIL trio

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

  29. Session switching with the tmux menu

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

  30. tmux output formatting

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

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

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

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

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

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

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

  37. fzf - the basics part 2 - search results

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

  38. fzf - the basics part 1 - layout

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

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

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

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

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

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

  43. MID$ and shell parameter expansion

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

  44. Understanding declare

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

  45. Desnowballification with set -o errexit

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

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

  47. curl and multipart/form-data

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

  48. Checking a command is available before use

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

  49. Using exec to jump

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

  50. A new learning source for shell scripting

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

  51. Shell parameter expansion with :+ is useful

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

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

  53. The open square bracket [ is an executable

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

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

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

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

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

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

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

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

  59. SAP Community Coding Challenge 2 - Finalists

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

  60. SAP Community Coding Challenge 2 - Contestants

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

  61. SAP Community Coding Challenge 2 - Update

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

  62. SAP Community Coding Challenge Nr.2

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

  63. Code at Home episodes

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

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

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

  65. Starting out with Raspberry Pi experiments

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

  66. My learning list for 2020

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

  67. Tech Aloud podcast - an introduction

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

  68. New podcast - Tech Aloud

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

  69. The Observer's Book of JS Style

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

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

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

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

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

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

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

  75. Debugging Fiori and UI5 - Materials

    A collection of pointers to material related to debugging UI5.

  76. Things I do to make my work life better

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

  77. Functional programming - baby steps

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

  78. The beauty of recursion and list machinery

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

  79. Reaching out to the new new kingmakers

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

  80. Language minutiae and learning to SWIM

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

  81. Finding a wonderland number

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

  82. Enlightenment in action

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

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

  84. 4Clojure Puzzle 66

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  94. My journey to Clojure

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

  95. openSAP Experiences

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

  96. Fiori & UI5 Related Videos

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

  97. Alt-K: Reading Notes

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

  98. Functional Python - Itertools Exploration

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

  99. 30 Days Challenges

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

  100. Recent Interests

    Visualising my recent blogging interests with a Wordle word cloud.

  101. On the Information Diet

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

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

    How I was inspired to read and learn more.

  103. Acorn Atom and my start in computing

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

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

See all tags.