Commits

Anonymous committed ebf9618

made some spellchecking

  • Participants
  • Parent commits bed42a1

Comments (0)

Files changed (5)

input/blog/agile-issue-tracker.md

 
 Posted on {{ page.date }}
 
-I don't know if you share my point of view, but I have to confess to a hatred
-of issue trackers.  I usually work on small projects with small teams (2-5
-developers), and I don't like monsters like Bugzilla or Redmine filled with the
-burocracy.
+I don't know if you share my point of view, but I have to confess to a
+hatred of issue trackers.  I usually work on small projects with small
+teams (2-5 developers), and I don't like monsters like Bugzilla or Redmine
+filled with the bureaucracy.
 
-Another thing is that in my head the word _"issue"_ has a bitter taste. I prefer
-the word _"task"_, because it doesn't make much difference to me when I'm
-implemenging a new long-expected feature or fixing an annoying bug.
+Another thing is that in my head the word _"issue"_ has a bitter taste. I
+prefer the word _"task"_, because it doesn't make much difference to me
+when I'm implementing a new long-expected feature or fixing an annoying
+bug.
 
-Finally, we live in the world of agile development and my issue tracker should
-be as flexible as I want it to be.
+Finally, we live in the world of agile development and my issue tracker
+should be as flexible as I want it to be.
 
-It's been a long way to realize that the issue track of my dream has always
-been right into my browser.
+It's been a long way to realize that the issue track of my dream has
+always been right into my browser.
 
 A spreadsheet, really?
 ----------------------
 
-Right, I picked a Google Docs spreadsheet to track my tasks/issues. Why not?
-It's already working on all platforms, including Android/iOS, it has offline
-mode, and Google Drive makes it even more pleasant.
+Right, I picked a Google Docs spreadsheet to track my tasks/issues. Why
+not?  It's already working on all platforms, including Android/iOS, it has
+offline mode, and Google Drive makes it even more pleasant.
 
-Next, I don't need to set up a server or pay for hosting, and several users can
-watch/edit bugs at the same time without any conflicts.
+Next, I don't need to set up a server or pay for hosting, and several
+users can watch/edit bugs at the same time without any conflicts.
 
-I can choose what characteristics of a bug are important for this project, and 
-create relevant columns for them.
+I can choose what characteristics of a bug are important for this project,
+and create relevant columns for them.
 
 A few words about the philosophy.
 
 I like kanban methodology. I think it's great for small agile projects.
-So I tried to make issue tracking look kanbanish.
+So I tried to make issue tracking look "kanbanish".
 
-There is a kind of backlog. All open issues that haven't been started yet are
-in the backlog.
+There is a kind of backlog. All open issues that haven't been started yet
+are in the backlog.
 
 When developers start working on the issue - it's marked as "started".
 When developer claims he fixed it - the issue gets "untested" status.
-Finally, after the fix is approved, the issue is maked as "closed".
+Finally, after the fix is approved, the issue is marked as "closed".
 
-Of course it's not a law, so some really simple issued can omit the "untested"
-status.
+Of course it's not a law, so some really simple issued can omit the
+"untested" status.
 
-There is one extra status - _"blocked"_. Issue can be blocked at any stage, by
-any reasons, so this status is somewhat special.
+There is one extra status - _"blocked"_. Issue can be blocked at any
+stage, by any reasons, so this status is somewhat special.
 
-To visualise progress I use color marks - every status has it's own visual
+To visualize progress I use color marks - every status has it's own visual
 style that is applied automatically.
 
-I'm not trying to reinvent the wheel. If I need to add commens on the issue
-(e.g. why it is blocked, or why it's reopened) I use "Comments" (Alt+F2).  They
-are easy to add, easy to read, and you can comment every cell separately.
+I'm not trying to reinvent the wheel. If I need to add comments on the
+issue (e.g. why it is blocked, or why it's reopened) I use "Comments"
+(Alt+F2).  They are easy to add, easy to read, and you can comment every
+cell separately.
 
-Also, if you want to see only the issue assigned to you - Google Docs "Filters"
-will help you.
+Also, if you want to see only the issue assigned to you - Google Docs
+"Filters" will help you.
 
 final form
 ----------
 
 Here's an example of my issue tracker for a tiny project.
 
-I have three columns: issue ID, short description, whom it's assigned to and
-issue status.  No priorities or deadlines - if they are really important they
-can be part of description, marked with bold font style or written in caps.
+I have three columns: issue ID, short description, whom it's assigned to
+and issue status.  No priorities or deadlines - if they are really
+important they can be part of description, marked with bold font style or
+written in caps.
 
-I like the idea I've stolen from .... - to strike-though closed issues. I also
-make font color lighter to distinguish them from the blocked issues.
+I like the idea I've stolen from .... - to strike-though closed issues. I
+also make font color lighter to distinguish them from the blocked issues.
 
-I've created a template to create new <del>spreadsheets</del> issue trackers easily,
-so feel free to use it if you like it
+I've created a template to create new <del>spreadsheets</del> issue
+trackers easily, so feel free to use it if you like it
 
 Let your code be bug-free!
 
 - CALL: store current address to the RS and jump to the address.
 This instruction makes it possible to implement functions.
 
-- ALU: perform ariphmetic operation
+- ALU: perform arithmetic operation
 
 There are 16 types of ALU instructions, each of them can also manipulate
 DS and RS stacks, change PC and work with memory. For more details
 COMPILER
 --------
 
-If you know Forth, you can use crosscompiler from the J1 project.
+If you know Forth, you can use cross-compiler from the J1 project.
 
-ALternatively, there is a separate project of developer tools for
+Alternatively, there is a separate project of developer tools for
 J1 CPU - [j1vm](http://bitbucket.org/zserge/j1vm)
 
 There is a Forth compiler `j1c` and a simulator (`j1vm`).
 return addresses when calling functions. You can put your local values
 there when playing with data stack, and fetch them later.
 
-Whan if you need a function like `( a b c d -- a+b c+d )`?
+What if you need a function like `( a b c d -- a+b c+d )`?
 First you call `+` and get `( a b c+d )`. But now you need to 
 remove that `c+d` from the top of the stack! You can move that item
 to the return stack. Use functions `>r` and `r>` to do that.
 If you need to store global variables, you can use memory-access functions: 
 `@` and `!`. They are "fetch" and "store" 
 
-It means, that `100 @` fetches 16-bit value from address 100, and `5 100 !` writes value 5 to address 100. At this moment variables and constants become handy.
+It means, that `100 @` fetches 16-bit value from address 100, and `5 100 !`
+writes value 5 to address 100. At this moment variables and constants become
+handy.
 
-Both variables and constants differ from what you normally see in Forth. To make a global variable you write:
+Both variables and constants differ from what you normally see in Forth. To
+make a global variable you write:
 
 	var my-var
 
-This allocates new variable address in RAM. If you need to make a constant definition write:
+This allocates new variable address in RAM. If you need to make a constant
+definition write:
 
 	equ X 10
 
-Now you can use them in your code: `my-var @` or `X my-var !`. Great thing is that you can use constants like variables if you need to use specific address (e.g. for memory-mapped I/O): 
+Now you can use them in your code: `my-var @` or `X my-var !`. Great thing is
+that you can use constants like variables if you need to use specific address
+(e.g. for memory-mapped I/O): 
 
 	equ GPIO 1234
 	( GPIO & 0x80 )
 Control structures
 ------------------
 
-At this point Forth is just an assembly language with weird syntax. Yes, it's compact, it's easy to learn and it's fast, but it's too much low-level. How do I make a loop? How to branch my code?
+At this point Forth is just an assembly language with weird syntax. Yes, it's
+compact, it's easy to learn and it's fast, but it's too much low-level. How do
+I make a loop? How to branch my code?
 
-It's easy. First, about branches. Internally, they use JZ/JMP instructions. The syntax is like:
+It's easy. First, about branches. Internally, they use JZ/JMP instructions. The
+syntax is like:
 
 	<condition> if <then-branch> else <else-branch> then
 	<condition> if <then-branch> then
 log.h
 =====
 
-log.h is a ultra-leight logging library for [nikl](nikl.html) framework.
+log.h is a ultra-light logging library for [nikl](nikl.html) framework.
 You can use it to profile your code or debug time-critical parts.
 
 idea
 ----------
 
 * No .c files, until they are really needed
-* This implies - no build system. You can take any compinations of modules you
+* This implies - no build system. You can take any combinations of modules you
   need and just copy or symlink them to your project directory
 
 
 * list-based data structures (list.h)
 * FORTH virtual machine (ivm.h)
 
-For the IVM there is a simple comiler written in Python (see "/utils/ivmc").
+For the IVM there is a simple compiler written in Python (see "/utils/ivmc").
 
 HOW TO USE TESTS
 ----------------
 	i'm using six IRC client and it's the best! <-- Jane reads this
 	wnat to try it?                             <-- and this, too
 
-Another piece of sugar is autoreply. When someone send you a message
-and you press `<tab>` his nickname is written as a recepient of your next
+Another piece of sugar is auto-reply. When someone send you a message
+and you press `<tab>` his nickname is written as a recipient of your next
 message:
 
 	<john> hi!