Difference between revisions of "Software Development"

From The Thinkulum
Jump to navigation Jump to search
m (Fixed the Essays category.)
(Added a caveat about centering on CLIs. Added behavior-driven development, PyRefactor, a README guide, Javadoc, code comments and self-documentation, project documentation, and a literate programming intro.)
Line 13: Line 13:
 
To give you an idea of my background, I've worked for the past 15 or so years in the publishing industry doing mostly text processing and some web development. The languages I'm most familiar with are Perl, Python, XSLT, and some JavaScript, with a smattering of PHP and VBA. I've spent almost all my time in Windows. I hope to branch out into at least Linux in the future, if only to expand my mind.
 
To give you an idea of my background, I've worked for the past 15 or so years in the publishing industry doing mostly text processing and some web development. The languages I'm most familiar with are Perl, Python, XSLT, and some JavaScript, with a smattering of PHP and VBA. I've spent almost all my time in Windows. I hope to branch out into at least Linux in the future, if only to expand my mind.
  
This guide will be oriented toward Python for now, but I imagine a lot of its suggestions apply to other languages too.
+
This guide will be oriented toward Python for now, but I imagine a lot of its suggestions apply to other languages too. At this point it also centers around desktop command-line programs, but I'm hoping to expand it into other interfaces and environments.
  
 
Since this guide is a place for me to learn, I welcome feedback, and I'm always open to arguments that my choices could be improved or suggestions for things I've missed.
 
Since this guide is a place for me to learn, I welcome feedback, and I'm always open to arguments that my choices could be improved or suggestions for things I've missed.
Line 93: Line 93:
  
 
Really I'll move back and forth between documenting, testing, and coding, but I'll check them off when I've completed the first instance of each of those subtasks for that function.
 
Really I'll move back and forth between documenting, testing, and coding, but I'll check them off when I've completed the first instance of each of those subtasks for that function.
 +
 +
A practice I'm starting to explore that takes TDD a step further is behavior-driven development. It allows you to derive tests from documentation that's both human readable and executable.
 +
 +
* [https://en.wikipedia.org/wiki/Behavior-driven_development Behavior-driven development - Wikipedia]
 +
* [https://github.com/cucumber/cucumber/wiki/Python Python - cucumber Wiki] - A short list of Cucumber alternatives for Python.
  
 
=== Refactoring ===
 
=== Refactoring ===
Line 99: Line 104:
  
 
I don't have a specific refactoring procedure in place. I just do it when I notice the need. I'm hoping to study Fowler's book and learn to think in terms of the structures that refactoring creates. That way I can create them as I code and reduce the need to refactor.
 
I don't have a specific refactoring procedure in place. I just do it when I notice the need. I'm hoping to study Fowler's book and learn to think in terms of the structures that refactoring creates. That way I can create them as I code and reduce the need to refactor.
 +
 +
Some IDEs have tools to aid refactoring. I'm planning to test using the Sublime Text plugin [https://packagecontrol.io/packages/PyRefactor PyRefactor] for refactoring Python.
  
 
== Version control ==
 
== Version control ==
Line 197: Line 204:
 
* '''Command line help''' - In the docstrings of command handling functions and at the top of a script. A reference that tells the user how to use the script and its command.
 
* '''Command line help''' - In the docstrings of command handling functions and at the top of a script. A reference that tells the user how to use the script and its command.
 
* '''Comments''' - Interspersed among lines of code. A reference that tells project developers what the code does and why.
 
* '''Comments''' - Interspersed among lines of code. A reference that tells project developers what the code does and why.
* '''Code conventions''' - Elements of coding style aimed at communicating the code's intentions. A reference that tells project developers and API users what the code does. Some developers try to substitute this technique for comments.
+
* '''Code self-documentation''' - Elements of coding style aimed at communicating the code's intentions. A reference that tells project developers and API users what the code does. Some developers try to substitute this technique for comments.
 
* '''Project documentation''' - In documents separate from the code. A cookbook and reference that gives users and developers thorough information for working with the project.
 
* '''Project documentation''' - In documents separate from the code. A cookbook and reference that gives users and developers thorough information for working with the project.
 
* '''Literate programming''' - Interspersed among chunks of code. A reference that gives developers detailed explanations of the reasoning behind the code. This type of documentation isn't common, but it could be a good idea for some projects.
 
* '''Literate programming''' - Interspersed among chunks of code. A reference that gives developers detailed explanations of the reasoning behind the code. This type of documentation isn't common, but it could be a good idea for some projects.
Line 207: Line 214:
  
 
=== README ===
 
=== README ===
 +
 +
Here's a recommendation of what to put in a README:
 +
 +
* [http://www.writethedocs.org/guide/writing/beginners-guide-to-docs/ A beginner’s guide to writing documentation - Write the Docs]
  
 
Here are some example READMEs that have helped me plan mine:
 
Here are some example READMEs that have helped me plan mine:
Line 228: Line 239:
 
* [https://www.python.org/dev/peps/pep-0257/ PEP 257 -- Docstring Conventions - Python.org]
 
* [https://www.python.org/dev/peps/pep-0257/ PEP 257 -- Docstring Conventions - Python.org]
 
* [http://stackoverflow.com/questions/3898572/what-is-the-standard-python-docstring-format What is the standard Python docstring format? - Stack Overflow]
 
* [http://stackoverflow.com/questions/3898572/what-is-the-standard-python-docstring-format What is the standard Python docstring format? - Stack Overflow]
 +
* [https://en.wikipedia.org/wiki/Javadoc Javadoc - Wikipedia] - A documentation generator for Java code. The conventions Javadoc understands can be adapted for other languages. I'm evaluating tools for processing Python docstrings that use this format.
  
 
My snippets for functions and modules will include docstring outlines.
 
My snippets for functions and modules will include docstring outlines.
  
Then you need a tool to present the docstrings to the reader. I'm going with Sphinx, since Python developers seem to prefer it. Since it formats more than just docstrings, I've put its links in the "Project documentation" section below.
+
Then you need a tool to present the docstrings to the reader. For now I'm going with Sphinx, since Python developers seem to prefer it. Since it formats more than just docstrings, I've put its links in the "Project documentation" section below.
  
 
=== Command line help ===
 
=== Command line help ===
Line 253: Line 265:
 
I haven't found any conventions for <code>cmd</code> help text, and the examples I've seen have been free-form descriptions. Maybe it would make sense to treat each command as a separate program and use usage message conventions for its help.
 
I haven't found any conventions for <code>cmd</code> help text, and the examples I've seen have been free-form descriptions. Maybe it would make sense to treat each command as a separate program and use usage message conventions for its help.
  
=== Comments ===
+
=== Comments and self-documentation ===
 +
 
 +
Comments and self-documentation are the two sides of the code clarity coin.
 +
 
 +
Code comments are one of the [http://www.hacker-dictionary.com/terms/holy-wars holy wars] of programming--everyone has a strongly held view and debates it vigorously. I basically agree with the views in these articles:
 +
 
 +
* [https://visualstudiomagazine.com/articles/2013/06/01/roc-rocks.aspx Why You Shouldn't Comment (or Document) Code - Visual Studio Magazine]
 +
* [https://sourcemaking.com/refactoring/smells/comments Comments - Source Making]
 +
* [https://www.pluralsight.com/blog/software-development/code-comments-dos-and-donts Code comments: A quick guide on when (and when not) to use them - Pluralsight]
 +
 
 +
That is, comments are a liability, so for the most part write them as little as possible, and update them when you update the code. Make your code as clear as you can (see the self-documentation section), and comment only to communicate what the code can't on its own, such as its purpose and the reasoning behind your choices in implementing it. If nothing else, comments can be a good indication of places that need refactoring.
 +
 
 +
I don't think it's necessary to stick to one procedure for commenting, but generally when I've commented more, it's because I've paused after a chunk of coding time, such as when I've finished a function. I code in paragraphs, sets of related lines separated by a blank line. In the commenting phase I reread the code I've just written and try to summarize or justify each paragraph, if needed. Stepping back from the code to state things in English sometimes leads to improvements in the code--refactoring or bug fixes.
 +
 
 +
Here are some in-depth discussions on making code self-documenting:
 +
 
 +
* [http://wiki.c2.com/?SelfDocumentingCode Self Documenting Code - WikiWikiWeb]
 +
* [http://wiki.c2.com/?SystemMetaphor System Metaphor - WikiWikiWeb]
 +
* [https://m.signalvnoise.com/hunting-for-great-names-in-programming-16f624c8fc03 Hunting for great names in programming - Signal v. Noise]
  
[TODO]
+
Every solution has its own problems. Self-documentation can go wrong too, and in some of the same ways comments can. For example, your function name doesn't have to have anything to do with its contents. Here are a bunch of tricks for wrecking your code's clarity:
  
=== Code conventions ===
+
* [http://mindprod.com/jgloss/unmain.html unmaintainable code - Java Glossary]
  
[TODO]
+
On the problem that documentation isn't executable, behavior-driven development might give us a partial solution. See the links in the test-driven development section above.
  
 
=== Project documentation ===
 
=== Project documentation ===
  
[TODO]
+
READMEs give the reader a basic intro to your project, but at some point they'll need more extensive information. I'm calling this in-depth treatment the project documentation.
 +
 
 +
==== Documentation generation ====
 +
 
 +
Some documentation is freeform writing, but using [https://en.wikipedia.org/wiki/Documentation_generator documentation generators] a lot of it can be collected from specialized comments and formatted automatically. You'd mainly use this to document your API. Sphinx is a popular Python tool for this purpose. It handles both types of documentation.
 +
 
 +
* [http://www.sphinx-doc.org/en/stable/ Sphinx]
 +
 
 +
My default Sphinx setup will be in my cookiecutter templates.
 +
 
 +
==== Content ====
 +
 
 +
I didn't find many guides to writing user or developer guides beyond the README, so I may have to write my own at some point, based on an examination of well-documented projects. But here's one guide that covers some of the information developers will need:
 +
 
 +
* [https://www.ctl.io/developers/blog/post/how-to-document-a-project How to Document a Project - CenturyLink Cloud Developer Center]
 +
 
 +
One source of insight for documenters might be the content of man pages. Man (manual) pages are the documentation for Unix tools, and they have a fairly standard format.
 +
 
 +
* [https://en.wikipedia.org/wiki/Man_page man page - Wikipedia]
 +
* [https://liw.fi/manpages/ Writing manual pages - Lars Wirzenius]
 +
* [http://www.schweikhardt.net/man_page_howto.html The Linux Man Page How-to - Jens Schweikhardt]
  
 
=== Literate programming ===
 
=== Literate programming ===
 +
 +
In spite of what I said about comments and self-documentation, sometimes I really want to expound on the meaning of my code, and literate programming is the way to do it.
  
 
* [https://en.wikipedia.org/wiki/Literate_programming Literate programming - Wikipedia]
 
* [https://en.wikipedia.org/wiki/Literate_programming Literate programming - Wikipedia]

Revision as of 22:44, 21 April 2017

Introduction

For most of my coding life, I have been the only user of my programs. I wrote them to aid my work or personal life, and only rarely did anyone else even see my code or watch it run. This wasn't on purpose. It just turned out that way. In my current job I do belong to a small development team, but our programs are still only for in-house use, so the only needs we have to consider are our own.

This situation is starting to change. My programming projects are becoming more relevant to the outside world, and I want to share some of them as open source. This means I'm needing to reshape some of my programming practices and learn some areas of software development I've had the luxury of ignoring all these years.

I haven't completely ignored these areas, though. I pick up on them here and there as I read about how other people code or see them in the software I use. Knowing that I'll probably need to know about them someday, I've kept a list. And now the time has come for me to fill in the details.

I'm filling in the details here in this guide for two reasons. First, as I learn, writing helps me clarify my thoughts and keep them flowing. And second, posting my writing might help other people. So if you're like me and you've programmed mainly for yourself--what I call private coding--and you're starting to share your work with others--public coding--then maybe what I've learned so far can grease some of your own planning.

This project consists of my reading other developers' advice, examining their code, deciding what to adopt and how to adapt it to my needs and preferences, and creating templates, procedures, reference materials, and anything else that might help me code well for a public user base.

To give you an idea of my background, I've worked for the past 15 or so years in the publishing industry doing mostly text processing and some web development. The languages I'm most familiar with are Perl, Python, XSLT, and some JavaScript, with a smattering of PHP and VBA. I've spent almost all my time in Windows. I hope to branch out into at least Linux in the future, if only to expand my mind.

This guide will be oriented toward Python for now, but I imagine a lot of its suggestions apply to other languages too. At this point it also centers around desktop command-line programs, but I'm hoping to expand it into other interfaces and environments.

Since this guide is a place for me to learn, I welcome feedback, and I'm always open to arguments that my choices could be improved or suggestions for things I've missed.

This is an early iteration of the guide, so it's incomplete, and a lot of it is only sketched out.

General coding guides

These are resources with advice on many aspects of writing good code. The ones I haven't read are on my to-read list. I'll probably be adding others.

Another resource that overlaps with this guide but covers more on the project management end of OSS is Producing Open Source Software.

Code examples

To show how I'm implementing these ideas in my own code, I'll refer to my GitHub repositories throughout the guide, mainly my templates for cookiecutter, a Python app that creates project skeletons for any language, and my snippets for Sublime Text 2, the text editor I use. Snippets are templates Sublime inserts wherever you type the corresponding trigger strings.

Here are projects that show up in lists of high quality code, so I'll examine some of them and include any relevant discoveries in the guide. All the projects I'm listing for now are in Python.

In addition to these, I keep a mental list of software with features I might want to emulate, even if I don't plan to study their code very thoroughly:

  • Firefox - automatic updating; possibly its add-on architecture, if it ever settles down
  • WordPress - plugin hooks

Software development methodology

I'll start with some general principles that direct my thinking about software development in general. These are the ideas behind agile development practices. Agile software development is a paradigm that was created to answer waterfall development, the approach of planning all the features of a piece of software in advance, an effort that often ends up wasted because the customer's needs change in the middle of the project, so the software has to be redesigned.

So agile development was intended to prevent overplanning. But using any development methodology will help prevent the opposite problem, which is a complete lack of structure and discipline. This results in a code organization scheme called a big ball of mud. I don't think my programs were complete mud, but the fact that I was the only one seeing or using my code let me get by with a lot of slacking. Slacking does keep you from working too hard, but it fails to prevent other kinds of problems. Agile software development seems like a good middle ground.

Agile development encompasses a lot of principles and practices, and it has a lot of varieties, but for me at this point, its most important practices are incremental development, test-driven development, and refactoring.

Incremental development

Incremental development is the approach of adding a few features per release rather than developing the whole program at once. It lets users begin using the software earlier, and it lets the feature roadmap change without wasting much development effort on the original design. It's different from iterative development, but they normally go together, so I'm use incremental as shorthand for both.

If you're a developer working on your own, the habit of small, frequent releases also can add accountability to the development process. It'll at least hold you accountable to work on the project, since other people will notice when the releases stop coming. It might even encourage you to code each feature well. A short release cycle does mean there's less time to get the code right, but there's also less time to procrastinate on getting it to work, and if you implement good programming practices, you'll waste less of that time debugging.

Small, frequent releases can also help the developer avoid procrastination, since the tasks for a small release feel more achievable, similar to writing a zeroth draft of a manuscript. There's little concern for polish, so a zeroth draft has fewer requirements to worry about, and therefore it's more likely to get written.

A related practice is to deliberately trim your feature list for each release, captured in the Extreme Programming practice You Aren't Gonna Need It.

One practice that's helping me think in terms of incremental development is using GitHub flow as my version control workflow. In GitHub flow the master branch is reserved for deployable code, so anything I'm actively developing goes into a topically named branch off of master. Once the code related to that branch is ready for deployment, I merge that branch back into master. This procedure gets me to plan in terms of small clusters of features. I'll talk more about version control in the next main section.

Test-driven development

To get myself into the habit of writing tests first, I'm including it as a subtask for each function I note in my task manager (I use Nirvana, an app designed with GTD in mind). I have a template for these subtasks, which I copy into the description of the tasks. At the moment the template looks like this:

- Document
- Test
- Code
- Commit

Really I'll move back and forth between documenting, testing, and coding, but I'll check them off when I've completed the first instance of each of those subtasks for that function.

A practice I'm starting to explore that takes TDD a step further is behavior-driven development. It allows you to derive tests from documentation that's both human readable and executable.

Refactoring

I don't have a specific refactoring procedure in place. I just do it when I notice the need. I'm hoping to study Fowler's book and learn to think in terms of the structures that refactoring creates. That way I can create them as I code and reduce the need to refactor.

Some IDEs have tools to aid refactoring. I'm planning to test using the Sublime Text plugin PyRefactor for refactoring Python.

Version control

I'm hosting my projects on GitHub (see the Distribution section), which means I'm using Git as my version control system. (Before that I was using Subversion via TortoiseSVN, which I still use for some non-GitHub projects.) I learned how to use Git from Git Essentials by Ferdinando Santacroce, and I try to follow its advice. For a reference I use Git Pocket Guide by Richard Silverman. Rather than typing all the Git commands myself, I'm lazy and use the GUI tool GitKraken. As I said above, I use the GitHub flow workflow to organize my commits. GitHub has as guide for it.

Coding style

I've picked up my coding style from various sources, including Perl Best Practices, but PEP 8 is a good starting point that's specifically geared toward Python.

Project structure

I make a directory on my local machine named whatever I'm using for the GitHub URL (e.g., math-student-sim), and I create this structure inside it:

docs/
<package>/
tests/
app.py
LICENSE.md
MANIFEST.in
README.md
setup.py

My package name is usually the project name without the hyphens (e.g., mathstudentsim).

I'll fill in more of the details in later sections.

Distribution

To distribute your code you need somewhere to host it, and I've chosen GitHub, since it's the one I hear the most about.

Installation

I haven't completely wrapped my mind around Python code distribution and installation, but for now I'm relying on people downloading the source from GitHub and running the setup script. Here are some more details on some of the issues that came up for me in the project structure guides above.

Metadata

Users of your project will need certain information about it, and you'll need to keep this information somewhere. For Python modules this is in the setup script.

Version numbers

I'm just following the guidelines in those articles.

License

I've picked MIT as my default to give people freedom to use the code however they want and because I don't expect to have patents to license.

Tests

Based on the advice in Learn Python the Hard Way, I've chosen nose as a test management tool, but since the future of nose is uncertain, I'm using nose2.

User interface

Command line

To make my projects usable quickly, I'm starting most of them with a command line interface.

I'm placing the commands in cli.py within the package.

Documentation

When you're coding for yourself, it's easy to forget about documentation, since you know how your code works and how to use it, and if you forget, you can reread it and figure it out. Deciphering your own code annoying, but possibly less annoying than writing documentation. Usually when I'm in my lazy, non-documenting mode, I comment pieces of the code during especially painful rereadings. I'd like to be nicer than that to people who aren't me.

Documentation comes in several different kinds, based on its location, format, and intended audience. It might help to think of documentation as falling into two basic genres: cookbooks and references. References tell you how the project works, and cookbooks tell you how to navigate through the project to reach particular objectives. Tutorials, for example, are a type of cookbook. Audiences fall into about three main categories: end users, API users who are developers using the code to write plugins or outside apps, and project developers.

As an overview, here's my take on the purpose and audience of documentation types you might find in Python projects, though most aren't limited to Python. Afterward I'll list links that discuss each type in more detail.

  • README - In a document in the root directory of the project. A cookbook that tells users and developers the basics of working with the project.
  • Docstrings - Mostly at the top of a function. A reference that tells API users how to use the function.
  • Command line help - In the docstrings of command handling functions and at the top of a script. A reference that tells the user how to use the script and its command.
  • Comments - Interspersed among lines of code. A reference that tells project developers what the code does and why.
  • Code self-documentation - Elements of coding style aimed at communicating the code's intentions. A reference that tells project developers and API users what the code does. Some developers try to substitute this technique for comments.
  • Project documentation - In documents separate from the code. A cookbook and reference that gives users and developers thorough information for working with the project.
  • Literate programming - Interspersed among chunks of code. A reference that gives developers detailed explanations of the reasoning behind the code. This type of documentation isn't common, but it could be a good idea for some projects.

General advice

README

Here's a recommendation of what to put in a README:

Here are some example READMEs that have helped me plan mine:

Here are some other lists of READMEs:

The initial README I came up with is here.

Docstrings

Here are discussions of what to put in a docstring:

My snippets for functions and modules will include docstring outlines.

Then you need a tool to present the docstrings to the reader. For now I'm going with Sphinx, since Python developers seem to prefer it. Since it formats more than just docstrings, I've put its links in the "Project documentation" section below.

Command line help

Traditional command-line programs are run from the OS command line, and their help statement is called a usage message. On Unix-like OSes they may also have a man (manual) page. I'll talk about man pages in the "Project documentation" section.

Python has the cmd module for creating a command-line interpreter within your program, and each of your program's commands can also have a help message, contained in the command function's docstring.

My snippets for scripts and command functions will include outlines for usage and help messages.

Usage message

Command help

I haven't found any conventions for cmd help text, and the examples I've seen have been free-form descriptions. Maybe it would make sense to treat each command as a separate program and use usage message conventions for its help.

Comments and self-documentation

Comments and self-documentation are the two sides of the code clarity coin.

Code comments are one of the holy wars of programming--everyone has a strongly held view and debates it vigorously. I basically agree with the views in these articles:

That is, comments are a liability, so for the most part write them as little as possible, and update them when you update the code. Make your code as clear as you can (see the self-documentation section), and comment only to communicate what the code can't on its own, such as its purpose and the reasoning behind your choices in implementing it. If nothing else, comments can be a good indication of places that need refactoring.

I don't think it's necessary to stick to one procedure for commenting, but generally when I've commented more, it's because I've paused after a chunk of coding time, such as when I've finished a function. I code in paragraphs, sets of related lines separated by a blank line. In the commenting phase I reread the code I've just written and try to summarize or justify each paragraph, if needed. Stepping back from the code to state things in English sometimes leads to improvements in the code--refactoring or bug fixes.

Here are some in-depth discussions on making code self-documenting:

Every solution has its own problems. Self-documentation can go wrong too, and in some of the same ways comments can. For example, your function name doesn't have to have anything to do with its contents. Here are a bunch of tricks for wrecking your code's clarity:

On the problem that documentation isn't executable, behavior-driven development might give us a partial solution. See the links in the test-driven development section above.

Project documentation

READMEs give the reader a basic intro to your project, but at some point they'll need more extensive information. I'm calling this in-depth treatment the project documentation.

Documentation generation

Some documentation is freeform writing, but using documentation generators a lot of it can be collected from specialized comments and formatted automatically. You'd mainly use this to document your API. Sphinx is a popular Python tool for this purpose. It handles both types of documentation.

My default Sphinx setup will be in my cookiecutter templates.

Content

I didn't find many guides to writing user or developer guides beyond the README, so I may have to write my own at some point, based on an examination of well-documented projects. But here's one guide that covers some of the information developers will need:

One source of insight for documenters might be the content of man pages. Man (manual) pages are the documentation for Unix tools, and they have a fairly standard format.

Literate programming

In spite of what I said about comments and self-documentation, sometimes I really want to expound on the meaning of my code, and literate programming is the way to do it.

Python tools:

  • pyWeb - After glancing at a few, I chose pyWeb as probably the closest to what I was looking for.
  • Pweave - A feature-rich tool I might try at some point.

My first attempt at literate programming is my Math Student Simulator. See the README for basic details on writing and processing the source files.

[More sections to come]

<disqus/>