c# adobe pdf reader control : Add page numbers to pdf control SDK utility azure winforms web page visual studio ScrumAndXpFromTheTrenchesonline07-314-part1824

| 31 
Just make sure you update the importance ratings in the Excel-based 
product backlog after the meeting. 
Time estimates are usually easier to do (and more accurate) if a story is 
broken down into tasks. Actually we use the term “activity” because the 
word “task” means something completely different in Swedish :o)  
This is also nice and easy to do with our index cards. You can have the 
team divide into pairs and break down one story each, in parallel.  
Physically, we do this by adding little post-it notes under each story, each 
post-it reflecting one task within that story. 
We don’t update the Excel-based product backlog with respect to our task 
breakdowns, for two reasons: 
! The task breakdown is usually quite volatile, i.e. they are 
frequently changed and refined during the sprint, so it is too 
much of a hassle to keep the product backlog Excel 
! The product owner doesn’t need to be involved at this level of 
detail anyway. 
Add page numbers to pdf - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add pages to pdf preview; add page numbers to pdf document
Add page numbers to pdf - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page numbers to a pdf; add page numbers pdf
32 | S
Just as with the story index cards, the task breakdown post-its can be 
directly reused in the sprint backlog (see pg 45 “How we do sprint 
Definition of “done” 
It is important that the product owner and the team agree on a clear 
definition of “done”. Is a story complete when all code is checked in? Or 
is it complete only when it has been deployed to a test environment and 
verified by an integration test team? Whenever possible we use the done 
definition “ready to deploy to production” but sometimes we have to 
make do with the done definition “deployed on test server and ready for 
acceptance test”.  
In the beginning we used to have detailed checklists for this. Now we 
often just say “a story is done when the tester in the Scrum team says so”. 
It is then up to the tester to make sure that product owner’s intent is 
understood by the team, and that the item is “done” enough to pass the 
accepted definition of done. 
We’ve come to realize that all stories cannot be treated the same. A story 
named “Query users form” will be treated very differently from a story 
named “Operations manual”. In the latter case, the definition of “done” 
might simply mean “accepted by the operations team”. That is why 
common sense is often better than formal checklists. 
If you often run into confusion about the definition of done (which we did 
in the beginning) you should probably have a “definition of done” field on 
each individual story. 
Time estimating using planning poker 
Estimating is a team activity - every team member is usually involved in 
estimating every story. Why? 
! At the time of planning, we normally don’t know exactly who 
will be implementing which parts of which stories. 
! Stories normally involve several people and different types of 
expertise (user interface design, coding, testing, etc).  
! In order to provide an estimate, a team member needs some kind 
of understanding of what the story is about. By asking everybody 
to estimate each item, we make sure that each team member 
understands what each item is about. This increases the 
likelihood that team members will help each other out during the 
C# Create PDF Library SDK to convert PDF from other file formats
them the ability to count the page numbers of generated PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
add page numbers to pdf online; add blank page to pdf preview
C# Word - Word Create or Build in C#.NET
also offer them the ability to count the page numbers of generated using this Word document adding control, you can add some additional Create Word From PDF.
add remove pages from pdf; add blank page to pdf
| 33 
sprint. This also increases the likelihood that important questions 
about the story come up early. 
! When asking everybody to estimate a story we often discover 
discrepancies where two different team members have wildly 
different estimates for the same story. That kind of stuff is better 
to discover and discuss earlier than later. 
If you ask the team to provide an estimate, normally the person who 
understands the story best will be the first one to blurt one out. 
Unfortunately, this will strongly affect everybody else’s estimates. 
There is an excellent technique to avoid this – it is called planning poker 
(coined by Mike Cohn I think). 
Each team member gets a deck of 13 cards as shown above. Whenever a 
story is to be estimated, each team member selects a card that represents 
his time estimate (in story points) and places it face-down on the table. 
When all team members are done the cards on the table are revealed 
simultaneously. That way each team member is forced to think for himself 
rather than lean on somebody else’s estimate. 
If there is a large discrepancy between two estimates, the team discusses 
the differences and tries to build a common picture of what work is 
involved in the story. They might do some kind of task breakdown. 
Afterwards, the team estimates again. This loop is repeated until the time 
estimates converge, i.e. all estimates are approximately the same for that 
C# PowerPoint - PowerPoint Creating in C#.NET
file but also offer them the ability to count the page numbers of generated NET using this PowerPoint document creating toolkit, if you need to add some text
adding page numbers to a pdf document; add pdf pages to word document
C# Word - Word Creating in C#.NET
document file but also offer them the ability to count the page numbers of generated using this Word document creating toolkit, if you need to add some text
add page to pdf reader; add pages to pdf
34 | S
It is important to remind team members that they are to estimate the total 
amount of work involved in the story. Not just “their” part of the work. 
The tester should not just estimate the amount of testing work.  
Note that the number sequence is non-linear. For example there is nothing 
between 40 and 100. Why?  
This is to avoid a false sense of accuracy for large time estimates. If a 
story is estimated at approximately 20 story points, it is not relevant to 
discuss whether it should be 20 or 18 or 21. All we know is that it is a 
large story and that it is hard to estimate. So 20 is our ballpark guess.  
Want more detailed estimates? Split the story into smaller stories and 
estimate the smaller stories instead! 
And no, you can’t cheat by combining a 5 and a 2 to make a 7. You have 
to choose either 5 or 8, there is no 7. 
Some special cards to note: 
! 0 = “this story is already done” or “this story is pretty much 
nothing, just a few minutes of work”. 
! ? = “I have absolutely no idea at all. None.” 
! Coffee cup = “I’m too tired to think. Let’s take a short break.” 
Clarifying stories 
The worst is when a team proudly demonstrates a new feature at the sprint 
demo, and the product owner frowns and says “well, that’s pretty, but 
that’s not what I asked for!”  
How do you ensure that the product owner’s understanding of a story 
matches the team’s understanding? Or that each team member has the 
same understanding of each story? Well, you can’t. But there are some 
simple techniques for identifying the most blatant misunderstandings. The 
simplest technique is simply to make sure that all the fields are filled in 
for each story (or more specifically, for each story that has high enough 
importance to be considered for this sprint). 
Example 1: 
The team and product owner are happy about the sprint plan and ready to 
end the meeting. The Scrum master says “wait a sec, this story named 
‘add user’, there is no estimate for that. Let’s estimate!” After a couple of 
rounds of planning poker the team agrees on 20 story points whereby the 
product owner stands up in rage “whaaaat?!”. After a few minutes of 
VB.NET TIFF: VB.NET Sample Codes to Sort TIFF File with .NET
manipulating multi-page TIFF (Tagged Image File), PDF, Microsoft Office If you want to add barcode into a TIFF a multi-page TIFF file with page numbers using VB
adding page numbers in pdf file; add page numbers to pdf in reader
C# Excel: Create and Draw Linear and 2D Barcodes on Excel Page
can also load document like PDF, TIFF, Word get the first page BasePage page = doc.GetPage REImage barcodeImage = linearBarcode.ToImage(); // add barcode image
add page numbers pdf files; add page number to pdf document
| 35 
heated discussion, it turns out that the team misunderstood the scope ‘add 
user’, they thought this meant ‘a nice web GUI to add, remove, delete, 
search users”, while the product owner just meant ‘add users by manually 
doing SQL towards DB’. They estimate again and land at 5 story points.  
Example 2: 
The team and product owner are happy about the sprint plan and ready to 
end the meeting. The Scrum master says “wait a sec, this story named 
‘add user’, how should that be demonstrated?” Some mumbling ensues 
and after a minute somebody stands up and says “well, first we log in to 
the web site, and then...” and the product owner interrupts “log in to the 
web site?! No, no, no, this functionality should not be part of the web site 
at all, it should be a silly little SQL script only for tech admins”.  
The “how to demo” description of a story can (and should) be very brief
Otherwise you won’t finish the sprint planning meeting on time. It is 
basically a high level plain-English description of how to execute the 
most typical test scenario manually. “Do this, then that, then verify this”.  
I have found that this simple description often uncovers important 
misunderstandings about the scope of a story. Good to discover them 
early, right? 
Breaking down stories into smaller stories 
Stories shouldn’t be too small or too big (in terms of estimates). If you 
have a bunch of 0.5-point stories you are probably going to be a victim of 
micromanagement. On the other hand, a 40-point story stands a high risk 
of ending up partially complete, which produces no value to your 
company and just increases administration. Furthermore, if your estimated 
velocity is 70 and your two top-priority stories are weighted 40 story 
points each, the planning gets kind of difficult. You have to choose 
between under-committing (i.e. taking just one item) and over-committing 
(i.e. taking both items). 
I find that it is almost always possible to break a large story into smaller 
stories. Just make sure that the smaller stories still represent deliverables 
with business value.  
We normally strive for stories weighted 2 - 8 man-days. Our velocity is 
usually around 40-60 for a typical team, so that gives us somewhere 
around 10 stories per sprint. Sometimes as few as 5 and sometimes as 
many as 15. That’s a manageable number of index cards to deal with. 
C# Excel - Excel Creating in C#.NET
document file but also offer them the ability to count the page numbers of generated using this Excel document creating toolkit, if you need to add some text
add pages to pdf in preview; add page number to pdf reader
VB.NET Image: Guide to Convert Images to Stream with DocImage SDK
Follow this guiding page to learn how to easily convert a single image or numbers of it an image processing component which can enable developers to add a wide
add page numbers to a pdf document; adding a page to a pdf file
36 | S
Breaking down stories into tasks 
Wait a sec, what’s the difference between “tasks” and “stories”? A very 
valid question. 
The distinction is quite simple. Stories are deliverable stuff that the 
product owner cares about. Tasks are non-deliverable stuff, or stuff that 
the product owner doesn’t care about.  
Example of breaking down a story into smaller stories: 
Example of breaking down a story into tasks: 
Here are some interesting observations: 
• New Scrum teams are reluctant to spending time breaking down a 
bunch of stories into tasks up-front like this. Some feel this is a 
waterfall-ish approach. 
• For clearly understood stories, it is just as easy to do this 
breakdown up-front as it is to do later. 
• This type of breakdown often reveals additional work that causes 
the time estimate to go up, and thereby gives a more realistic 
sprint plan. 
• This type of breakdown up-front makes daily scrum meetings 
noticeably more efficient (see pg 61 “How we do daily scrums”).  
C#: Use XImage.OCR to Recognize MICR E-13B, OCR-A, OCR-B Fonts
may need to scan and get check characters like numbers and codes. page.RecSettings. LanguagesEnabled.Add(Language.Other); page.RecSettings.OtherLanguage
add pages to pdf preview; add page to pdf in preview
C# Word: How to Use C# Code to Print Word Document for .NET
are also available within C# Word Printer Add-on , like pages at one paper, setting the page copy numbers to be C# Class Code to Print Certain Page(s) of Word.
adding page to pdf in preview; add page numbers to pdf in preview
| 37 
• Even if the breakdown is inaccurate and will change once work 
starts, the above advantages still apply. 
So, we try to make the sprint planning time-box long enough to fit this in, 
but if time runs out we let it drop out (see “Where to draw the line” 
Note – we practice TDD (test driven development) which in effect means 
that the first task for almost each story is “write a failing test” and the last 
task is “refactor” (= improve code readability and remove duplication).  
Defining time and place for the daily scrum 
One frequently-forgotten output of the sprint planning meeting is “a 
defined time and place for the daily scrum”. Without this your sprint will 
be off to a bad start. The first daily scrum is essentially the kickoff where 
everybody decides where to start working. 
I prefer morning meetings. But, I must admit, we haven’t actually tried 
doing daily scrums in the afternoon or mid-day.  
Disadvantage of afternoon scrums: when you come to work in the 
morning, you have to try to remember what you told people yesterday 
about what you will be doing today. 
Disadvantage of morning scrums: when you come to work in the 
morning, you have to try to remember what you did yesterday so that you 
can report this. 
My opinion is the first disadvantage is worse, since the most important 
thing is what you are going to do, not what you did 
Our default procedure is to select the earliest time at which nobody in the 
team groans. Usually 9:00, 9:30, or 10:00. The most important thing is 
that it is a time which everybody in the team can wholeheartedly accept.  
Where to draw the line 
OK, so time is running out. Of all the stuff we want to do during the sprint 
planning, what do we cut out if we run out of time? 
Well, I use the following priority list: 
38 | S
Priority 1: A sprint goal and demo date. This is the very least you need to 
start a sprint. The team has a goal, an end date, and they can work right 
off the product backlog. It sucks, yes, and you should seriously consider 
scheduling a new sprint planning meeting tomorrow, but if you really 
need to get the sprint started then this will probably do. To be honest, 
though, I have never actually started a sprint with this little info. 
Priority 2: List of which stories the team has accepted for this sprint. 
Priority 3: Estimate filled in for each story in sprint.  
Priority 4: “How to demo” filled in for each story in sprint. 
Priority 5: Velocity & resource calculations, as a reality check for your 
sprint plan. Includes list of team members and their commitments 
(otherwise you can’t calculate velocity). 
Priority 6: Specified time and place for daily scrum. It only takes a 
moment to decide, but if you run out of time the Scrum master can simply 
decide this after the meeting and email everyone.  
Priority 7: Stories broken down into tasks. This breakdown can instead 
be done on a daily basis in conjunction with daily scrums, but will slightly 
disrupt the flow of the sprint.  
Tech stories 
Here’s a complex issue: Tech stories. Or non-functional items or whatever 
you want to call them.  
I’m referring to stuff that needs to be done but that is not deliverable, not 
directly related to any specific stories, and not of direct value to the 
product owner. 
We call them “tech stories”.  
For example:  
Install continuous build server 
o Why it needs to be done: because it saves immense 
amounts of time for the developers and reduces the risk 
of big-bang integration problems at the end of an 
| 39 
Write a system design overview 
o Why it needs to be done: Because developers keep 
forgetting the overall design, and thereby write 
inconsistent code. Need a “the big picture” document to 
keep everyone on the same page designwise. 
Refactor the DAO layer 
o Why it needs to be done: Because the DAO layer has 
gotten really messy and is costing everyone time due to 
confusion and unnecessary bugs. Cleaning the code up 
will save time for everyone and improve the robustness 
of the system. 
Upgrade Jira (bug tracker) 
o Why it needs to be done: The current version is too 
buggy and slow, upgrading will save everyone time. 
Are these stories in the normal sense? Or are they tasks that are not 
connected to any specific story? Who prioritizes these? Should the 
product owner be involved in this stuff? 
We’ve experimented a lot with different ways of handling tech stories. 
We tried treating them as first-class stories, just like any others. That was 
no good, when the product owner prioritized the product backlog it was 
like comparing apples with oranges. In fact, for obvious reasons, the tech 
stories were often given low priority with the motivation like “yeah guys, 
I’m sure a continuous build server is important and all, but let’s build 
some revenue driving features first shall we? Then you can add your tech 
candy later OK?”  
In some cases the product owner is right, but often not. We’ve concluded 
that the product owner is not always qualified to be making that tradeoff. 
So here’s what we do: 
1) Try to avoid tech stories. Look hard for a way to transform a tech 
story into a normal story with measurable business value. That 
way the product owner has a better chance to make correct 
2) If we can’t transform a tech story into a normal story, see if the 
work could be done as a task within another story. For example 
“refactor the DAO layer” could be a task within the story “edit 
user”, since that involves the DAO layer. 
3) If both of the above fail, define it as a tech story, and keep a 
separate list of such stories. Let the product owner see it but not 
edit it. Use the “focus factor” and “estimated velocity” 
40 | S
parameters to negotiate with the product owner and bend out 
some time in the sprint to implement tech stories. 
Example (a dialogue very similar to this occurred during one of our sprint 
planning meetings).  
Team: “We have some internal tech stuff that needs to be done. 
We would like to budget 10% of our time for that, i.e. reduce 
focus factor from 75% to 65%. Is that OK?” 
Product owner: “Hell no! We don’t have time!” 
Team: “Well, look at the last sprint (all heads turn to the velocity 
scrawls on the whiteboard). Our estimated velocity was 80, and 
our actual velocity was 30, right?” 
PO: “Exactly! So we don’t have time to do internal tech stuff! 
Need new features!” 
Team: “Well, the reason why our velocity turned out to be so 
bad was because we spent so much time trying to put together 
consistent releases for testing”. 
PO: “Yes, and?” 
Team: “Well, our velocity will probably continue being that bad 
if we don’t do something about it.” 
PO: “Yes, and?” 
Team: “So we propose that we take approximately 10% off of 
this sprint to set up a continuous build server and other stuff that 
will take the pain off of integration. This will probably increase 
our sprint velocity by at least 20% for each subsequent sprint, 
PO: “Oh really? Why didn’t we do this last sprint then?!” 
Team: “Er... because you didn’t want us to...” 
PO: “Oh, um, well fine, sounds like a good idea to do it now 
Of course, the other option is to just keep the product owner out of the 
loop or give him a non-negotiable focus factor. But there’s no excuse not 
to try to reach consensus first.  
If the product owner is a competent and reasonable fellow (and we’ve 
been lucky there) I suggest keeping him as informed as possible and 
letting him make the overall priorities. Transparency is one of the core 
values of Scrum, right?  
Documents you may be interested
Documents you may be interested