TPXimpact DX Tech Handbook
  • DX Tech Handbook
  • Processes
    • Decision making
      • RFC Template
    • Communities of practice
    • Dealing with change
    • AI generated code
    • Guidance on billing for junior developers
    • Our hiring process
    • Job Descriptions
  • Working practices
    • Version control
    • Drupal 9 upgrade
    • Site health check list
  • Best practice
    • Non functional requirements
    • Security updates
    • Browser compatibility and testing
    • Writing good commit messages
    • 🚛Load testing
  • 📕Recommended reading
  • Learning resources
    • Learning Drupal
    • Contentful training
    • Acquia DAM Certification
Powered by GitBook
On this page
  • Thinking in components
  • Design systems
  • Programming concepts
  • Agile methodologies
  • Frontend

Was this helpful?

Recommended reading

A curated list of foundational ideas and concepts the team has absorbed and made part of the "TPX DX Way"

PreviousLoad testingNextLearning Drupal

Last updated 1 year ago

Was this helpful?

Thinking in components

This is a good overview of the background thinking behind React and component development as an approach.

This talk called React is Fiction, is probably one of the best conference talks we've seen in a long time. The 'software developers as fiction authors' analogy is a little stretched at times but the point being made about how to make good decisions about developing good software components is required viewing and understanding

Design systems

Programming concepts

Agile methodologies

Frontend

Here as well is a brilliant piece on maintainable style guides - the problem here will be familiar to anyone who's worked on a template based CMS (like Drupal / WordPress and probably Umbraco) If you've not seen this before, Brad Frost's talk on his Atomic Design approach to component development is also good as he describes the problems in web development well (although his answer of Pattern Lab is too heavy weight for our liking)

It would also be useful to have a basic grasp on Functional programming (in particular why mutable state should be avoided). The following article I've found excellent as an introduction to the topic (note it doesn't appear to be about this at first)

As Technical Architects, you'll find that during a lot of the decision making we do we like to pull back to the following description of 'Simple versus Easy' based technical choices

Our big build project process uses a version of Agile called DSDM - this is a pretty good description of it:

Here's a nice archive of blog posts that shape a lot of modern thinking about how to work with the web:

This work is licensed under a .

📕
https://engineering.lonelyplanet.com/2014/05/18/a-maintainable-styleguide.html
https://vimeo.com/179245570
https://web.archive.org/web/20220107073531/http://damienkatz.net:80/2006/04/error_code_vs_e.html
https://www.infoq.com/presentations/Simple-Made-Easy/
https://www.deeson.co.uk/blog/dsdm-agile-e2-80-98projects-e2-80-99
https://esif.dev/
Creative Commons Attribution-ShareAlike 4.0 International License
Creative Commons Licence