Review Sprint 2

We all managed to get the OpenMRS and AMPATH running and working together, every though it took us a while. We did not finish modifying the angular code for the login page, so we will have to throw this back on our sprint tasks. As of now we are all on the same page.

This sprint was a little bit unorganized. Rather than working as a group we kind of did out own thing, and left others behind. In the future i think we should have one person project their screen, and have the group follow what they are doing. This way we make sure that everyone is on the same page. During this sprint some people finished almost all of the tasks, and others finished them almost a week later. This made it hard to progress as a group.

From the blog CS@Worcester – Site Title by jonathanpaizblog and used with permission of the author. All other rights reserved by the author.

Clean Coder Chap 9+10, Week 5

Time Management:

Time management is key to accomplishing most tasks in life especially programming. Time is precious; do not waste time. Meetings are necessary, but often are time wasters. Keep discussions brief within meetings, try not to keep everyone there trying to solve a problem in the meantime. Keeping focus all the time is a tough task, especially with software development, but you can break up your day with simpler tasks. This directly applies to us but more in the sense of managing other classes/work on top of our programming.

Estimation:

Estimation will always cause uncertainty. One of the hardest questions a developer will ever have to answer is how long something will take. The PERT technique computes distributions based off best-case, nominal, and worst-case estimates for the project.

From the blog CS@Worcester – Kyle Polewaczyk by kpolewaczyk and used with permission of the author. All other rights reserved by the author.

Clean Coder 9 & 10, (Week 5)

The ninth chapter of the Clean Coder book is about time management. The is only 28,800 seconds in a working day and it is the duty of a professional to use those precious few seconds effectively. According to the author meetings take a lot of time and money; as professional you need to know when to go to a meeting you are invited and when to decline.

The advice that I found most interesting was the following: any argument that can’t be settled in five minutes can’t be settled by arguing; and so there is no point wasting meeting time to try and resolve the issue. The other interesting thing is the Pomodoro technique to manage time and focus.

The tenth chapter of the book was about estimation and how to make valid estimations. The author explains and differentiates between the concept of an estimation vs. a commitment. He also talks about the different ways to make estimations.

There is not much that is new to me in chapter 9, but I found some of the estimation techniques useful. I plan to try out those techniques in our ng2-amrs project.

From the blog CS448 – The blog about software by Sudarshan and used with permission of the author. All other rights reserved by the author.

The Clean Coder 9 & 10 Week 5

In the first section of the reading time management was discussed. One of the biggest time wasters could be meetings, they may seem important but many times they are not manditory. If you feel you are getting nothing out of a meeting, then leave. A big issue with wasting time is if you are not focused. Do your best to stay focused because if you’re not you’re not going to get anything done. A few strategies to help stay focused is take breaks, get enough sleep, drink caffeine, etc. I know if I’m tired and can’t focus it takes me twice as long as if I were focused.

The next section talks about estimations in your project. Theres a big difference between a commitment and an estimate. A commitment you must follow through with in your professional career, an estimate is a guess on your part and most likely will not be accurate. The best way to estimate tasks is to ask the people around you, they might actually know more about when you can complete a certain task. As a professional software developer you will become better at estimates, even though things could still happen that will throw your estimate way off.

From the blog CS@Worcester – Software Testing by kyleottblog and used with permission of the author. All other rights reserved by the author.

The Clean Coder: Chapters 9 & 10

Chapter 9 covers the topic of time management. The first thing that is talked about is meetings. They are necessary yet frequently very wasteful of time. The author lays out some guidelines to approach work day meetings. The first suggestion is to not attend every meeting. Only choose the ones that are of value to you or require your attendance. Next is to politely decline meetings which aren’t well structured. Meetings should have an outline of talking topics and talking times clearly defined. Lastly is to not be afraid to excuse yourself from a meeting which has either gone off topic or possibly dragging on. Next the author touches upon some things you can do to help keep focused at work. He mentions adequate sleep, consuming some caffeine (but not too much), and breaking with non-work activities to include exercise. The author goes on to mention a time interval strategy called tomatoes which is a Pomodoro technique. Basically you set a 25 minute timer and during the time you deflect any phone calls, issues, or other distractions. After the 25 minutes is up you deal with side tasks and possibly take a short break. When you’re ready, you start the timer again. Lastly, the author talks about blind alleys and software messes. The main message is to never go too far into something that can’t be abandoned. Furthermore it is always easier to turn back at the current time than to keep moving in the wrong direction.

After reading chapter 9 there are definitely some good tips to keep in mind to improve time management skills. The tomatoes technique seems like it would be an effective way to stay productive during the workday. Each time you start the clock you are dedicating 25 undistracted minutes towards completing a main work task. This is something I will try to put in practice especially on days that seem like they may be slipping away. Another tip I will keep in mind is to avoid priority inversion. I am definitely guilty of changing my priorities based on how I feel about tasks rather than doing them in the order they truly should be done. Recognizing that I do this, I will try to be more aware of how I rank my daily tasks and make sure they are correctly prioritized. I thought the section on “focus-manna” was not entirely necessary. Every working adult knows that sleep, exercise, and coffee are going to help performance on just about anything. I also wasn’t in complete agreement about leaving a meeting. If you have committed to attend a meeting I think it would be rude to leave before it is over and it may rub off the wrong way on co-workers. I would finish the meeting I was in but be more mindful of what meetings I attended in the future. Overall this has probably been my least liked chapter so far. I think that chapter assumed too many ideals and I didn’t agree with everything that was mentioned. Still, it is important to remember that the author is one of the most respected software professionals there are so his advice should always be digested and considered.

Chapter 10 covers the topic of estimating completion dates. It is made clear that a commitment and estimation are very different from each other. A commitment is something that must be accomplished and has a hard date associated with it. An estimation is not a promise but a likelihood or ballpark figure. As the author mentions it is best to outline a probability distribution for the likelihood of different time frames. One technique he mentions is PERT which uses a trivariate analysis. Basically a developer will make an optimistic, nominal, and pessimistic estimate and rate the likelihood of each. This gives management a planning guideline they can work with and better communicates deadlines. The author also mentions a popular estimation technique which has many forms called “wideband delphi.”  The main idea of this strategy is to make group estimates of tasks and projects. This gives more accurate estimates as well as ensures the entire team is in agreement. Lastly the author refers to the Law of Large Numbers in the sense that projects should be broken down into smaller tasks and each of those tasks should be given an individual estimate. The total of the all these tasks added up should be more accurate due to the better attention of detail the project may require.  In conclusion, the author suggests being cautious with commitments because they must be mandatorily met. A well thought estimate is usually the best course of action for a professional developer.

After reading chapter 10 I will be more careful of things I fully commit myself to. I definitely think that team estimating would be the most effective and accurate strategy. As a new developer it would be tough to give confident estimates so a group setting would surely help guide accuracy. If a team is implementing the Scrum framework then they are already following most of the guidelines in this chapter. While I think the trivariate analysis is also a good strategy to gauge likelihood, actually calculating a probability distribution seems like overkill. I may be wrong but I don’t think most work environments will require such calculations for every task and project. In summary, Scrum continues to be a framework which encompasses many of the guidelines and suggestions covered in this book

From the blog CS@Worcester – Software Development Blog by dcafferky and used with permission of the author. All other rights reserved by the author.

The Clean Coder, Chapter 7 & 8

This week of reading: Chapter 7: Acceptance Testing and Chapter 8: Testing Strategies from The Clean Coder by Robert C. Martin, covered importance of acceptance testing and the role of Quality Assurance (QA) in the designing, building and delivering of a successful product.

In chapter 7, Uncle Bob explained that there is often misinterpretation and miscommunication between the stakeholders and programmers. One remedy to clear this uncertainty between stakeholders and programmers is to use acceptance testing. Acceptance tests eliminates communication errors between programmers and stakeholders. As Uncle Bob stated, “They are completely unambiguous”. Acceptance tests clears up the communication between what the stakeholders wants and what the programs should deliver. These tests can also be looked as a perfect requirements document.

In chapter 8, Uncle Bob elaborates on the different testing strategies in order to strive for an attempt that QA should find no bugs or defects in the software/product. For this Uncle Bob suggests that first, development team in an organization have to count QA team as part of their team rather than treat them as their adversaries. Development team have to work closely with QA to arrange hierarchy of unit, component, integration, system and exploratory tests. These tests should be run as often as possible which will assure clean system with maximum feedback.

So far in the semester, we been constantly discussing and defining what do we mean when we say we are done? By reading these chapters, it cleared up what does ‘done’ means for a professional developer. Uncle Bob states, “Done means all code written, all tests pass, QA, and the stakeholders have accepted.” Normally, every person or team has their own meaning and definition of done, but when it comes to the business world we have to be on top of our game. We have to be responsible for not only ourselves, but we have to make sure that the team thrives too, and is successful in completion of the project. I believe, I can apply this strategy to our own team projects at university and in professional career that my team’s success is my success. In order to do this, I should be as transparent, positive and open as I can be with my team members. We should reach the ‘done’ part together, not individually.

From the blog Software Learning and Development – Haider Hussain by hhussainsite and used with permission of the author. All other rights reserved by the author.

Clean Coder, Chapter 7 & 8

Chapter 7:

Chapter 7 is titled Acceptance Testing. Well that is kind of strange because one of the chapters in the book for Software Quality Assurance and Testing was all about this and I wrote a blog Post about this very topic. Acceptance Testing is the process of asking the customers about what they really thing the software you are making should do, IE its behavior. This will give you a set of requirements that you can use to create acceptance tests. Then these would be used to set a proper definition of done, like he explained in an earlier chapter. So when the software behaves correctly and passes the tests you are finished. This way of testing helps to clear up any trouble in the beginning and end of a project.  This helps everyone get on the same page. The developer and the customer will understand what the software should do and how it should behave.

Chapter 8:

Chapter 8 was titled Testing Strategies and guess what? You guessed it! This chapter is all about Testing Strategies. This chapter helps to outline some good strategist to use when testing. One of which is to develop tests so QA isn’t necessary. What I mean by this is if you find no bugs then QA can focus on harder problems and everyone helps to make a better product. The author then details the Test Automation Pyramid. Sadly it’s not a transformer. But they do include a nice diagram of the pyramid.

capture
From Clean Coder by Robert C. Martin

This pyramid looks quite daunting but it really isn’t. The bottom layer is Unit test which are written by  programmers and for programmers. These test should be run constantly as a part of continuous integration. Next is component tests, these tests encapsulate a component. These tests are written by QA and Business with assistance from development. Integration tests test how well the assembly of components work together. System tests are automated tests that are executed against the whole system some tests in this section are throughput and performance tests. Finally Manual Exploratory tests are human made tests to explore the system for unwanted behaviors. In summary all parts of a company should work together and have a good strategy when it comes to testing.

From the blog CS@Worcester – Conundrums In Computing by patrickgrahamblog and used with permission of the author. All other rights reserved by the author.

Clean Coder, Chapter 5 & 6

Chapter 5:

Chapter 5 is titled Test-driven Development.  The Concept of test driven development might sound odd at first.  I mean writing tests first? To me it was very weird because I normally dive head first into any problem I am challenged with.  For the most part it has worked out but, TTD sounds like a more logical and strategic way to code.  It would be like knowing the questions to a test before taking it.  Planning your study session with the questions is a significantly easier way to study.  Well it sounds better written out, why didn’t I think of it earlier? Anyway, TDD is writing tests that fail then only writing enough code to make those tests pass.  It can help with not breaking the entire thing by knowing what’s failing and what’s not.  So if you write a new piece of code and all the tests fail, Then you know you messed up.

Chapter 6:

Chapter 6 is titled Practicing.  Well everyone knows that you cannot get better at something without practice.  But, sometimes you have to be told that before it gets in your head.  There is a saying that most know, it goes something like “the master has failed more than the apprentice has even thought of trying.”  This supports the argument of practice makes perfect.  Anyway, The author talks about a martial arts technique Kata and what it means in programming.  This is a set of keystrokes that simulate solving a problem.  This problem you already know the answer to.  Then he details some other types of Kata like Wasa and Randori that involve more people.  The entire chapter helps to enforce the idea that professionals all practice.

From the blog CS@Worcester – Conundrums In Computing by patrickgrahamblog and used with permission of the author. All other rights reserved by the author.

Week 4: The Clean Coder

I read chapter 7 & 8 of the clean coder this week.  To sum up chapter 7, it basically talked about how important it is to write automated acceptance tests.  Communication between two parties can be extremely difficult in the workplace.  There are many times where a customer and a developer, or really any two parties might think they completely agree on all the details they discussed, but in reality they might leave having two totally separate ideas.  It is very easy to assume someone understands something when in fact they aren’t on the same page at all.  This chapter showed me that writing these acceptance tests are a great way to solve the problem of miscommunication in the computer science field.  The chapter defines acceptance tests as, “tests written by collaboration of the stakeholders and the programmers in order to define when a requirement is done”.  I really enjoyed reading this chapter.  It brought light to my eye that there is a way to fix the problems of not getting across what will be done clearly and precisely.  I remember in class we talked about “the definition of done”, and this chapter also discussed this.  Your definition of done can be completely different then the person sitting next to you.  It is very important to clarify specifically when discussing what is going to be done so everyone is on the same page.  I remember I had a presentation once and I thought one of the members in my group was going to make slides on a certain topic.  When it came the day to present, we realized that we completely miscommunicated and ended up both doing the same thing.  This chapter reminded me of this specific time.  It’s a good idea to follow this practice in order to prevent these types of things from happening in the workplace.

Chapter 8 discussed how important it is to constantly test your code as a developer.  This chapter touched on 5 main types of testing that should be run as frequently as possible.  1.

  1. Unit Testing
  2. Component
  3. Integration
  4. System
  5. Exploratory

I could not agree with this chapter more.  The deeper I get into the field of computer science and programming, the more I am starting to see the importance in testing.  Although testing can be extremely tedious and boring, it is something that you must do as a professional engineer.  Many developers tend to think that they don’t need to test anything because that’s the QA’s job.  However, this is not true at all.  This chapter talked about the importance of the developers and QAs working together to test EVERYTHING.  An interesting statement that was mentioned in this chapter was, “It should be the goal of the development group that QA find nothing wrong.” I really liked what the author said and I agree.  In order to be a great coder, you need to not only be able to write a good program, but you also need to write good tests so you can catch the problems before the QA, or worse, the customer.

From the blog CS@Worcester – Alex's Comp Sci Blog by alexsblog13 and used with permission of the author. All other rights reserved by the author.

The Clean Coder Chapters 7 and 8

 

This week we were assigned to read chapters 7 and 8 in The Clean Coder. Acceptance testing ensures that the code is working to standards according to the customer’s needs. This is important because sometimes requirements may be ambiguous and up for interpretation. These tests are put in place to set some sort of framework down so developers have something to work around. Sometimes after discussing with the customer, developers may have different ideas than what the customers actually want. Putting these tests in place is necessary because they act as “the perfect requirements document”.

Chapter 8 is about testing. Just because you have a QA department, does not mean you can leave all the errors in your code for them. You should aim for your code to be 100 percent error free when you pass it off the QA. It would be wise to work with QA to create unit tests, component test, integration test, system tests, and exploratory tests. It is important that you use all of these testing strategies to make sure your code stats bug and error free, and it working to standard.

From the blog CS@Worcester – Site Title by jonathanpaizblog and used with permission of the author. All other rights reserved by the author.