CognitiveEnvironments

Programming

Principle

Explicitly facilitate being in the most efficient environment to produce and continuously improve code.

Specific environments (to cycle through)

Clarifying the problem to solve

  • where is the value?
  • ?

Architecture design

  • what is organization decision will have the biggest impact of the code maintanability and extensibility?
  • ?

Implementing

  • do I understand the good practice of the language? environment? paradigm?
    • do I apply them?
  • periodically compare own produced code to
    • beginners, intermediate, veterans
  • ?

Debugging

  1. construct the most likely hypothesis
  2. check available log to confirm it
    1. if it is correct, modify the code to fix it
    2. if it is not, modify the hypothesis and cycle again

See also delta debugging.

Refactoring

  • does the code smell?
  • does code coverage shows that most of the code is rarely used thus should not be spent so much time on?
  • reconsider ArchitectureDesign, now that the code has been used what has changed and consequently how should the code reflect that?
  • ?

CodeRefactoring displays the RSS to periodically propose refactoring to keep the code clean, yet tools could help for code smell, code coverage and usage.

See also Programming#Refactoring

Testing

  • how can I make sure that the code does what it should do?
    • and only that?
  • ?

Documenting

  • who will be the persons most interacting with the code?
    • by usage? by maintenance? by integration? by extending it?
  • ?

Improving process

Clarify the steps required for an efficient workflow and what can support them.

  • Git#WikiIntegration
  • Programming for general links
  • Testbed:. to facilitate tests
  • wiki integration
  • hooks
    • facilitating following a proposed paradigm by being integrated as the workflow
      • e.g. ΦFP (and the recently read WithoutNotesJuly11#GraphsBrainsAndGremlin which seems pretty coherent with it)
      • consider also integrating with different checkers for each layer of the stack e.g. PHP interpreter errors and warnings, Javascript engine, HTML validators, w3c linkcheck, ...
    • quality checking
      • local pre-commit with software analyzers e.g. [[Tools/JavaScript files with jslint, frama-c or coccinelle, Simian (Similiarity Analyzer), Stylecop, Fxcop, ndepend
      • it might be better to do so earlier in the process, e.g. in the IDE like Vi
      • on the last commit that is adding lines check against code repositories e.g. Programming#CodeReUse (or directly tools listed there) using language vocabulary (rather than words in texts) and a technique e.g. LDA to suggest similar code to study, ideally labeled as of good quality snippets
        • even though it can be done via a hook, this might be problematic in the workflow, consequently this could be updating a document to review later on during a moment more adapted for learning
    • automated deployment
      • local post-commit and remote post-receive hooks which
        • rsync the right files to the right locations
        • verify that the configuration calling file is ok else update them
        • package a content-free self-explanatory structured and configured version
          • eventually with a small httpd and an installer
          • a nightly package might be more adapted though
        • log the result, eventually create an RSS for problems
        • maintain the other "distribution channels"
          • e.g. PmWiki official list of recipes with for each the page and eventually its attachment
            • thus probably requiring a curl post request
        • generate screenshots
          • (if not working on a library) change in the interface in any way have to generate screenshots and associated thumbnails as people do not judge the result by internal changes or how the code repository is going but by how it looks
      • cf TheArtOfLeanSoftwareDevelopment#Chapter2

Methods and techniques

Notes on content

To do

  1. check Wikipedia:Philippe Kahn#Philippe.27s_3_Rules_of_Software_Craftsmanship
  2. read Sylvain Ross' Software production heuristics
  3. consider Vim (or other tools) integration to be part of the workflow
  4. periodically step back
    1. e.g. read http://www.antoarts.com/10-ways-to-improve-your-programming-skills/
    2. reorganize resources on this wiki, in particular Programming

GreenMarinee theme adapted by David Gilbert, powered by PmWiki