Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Week 6 reflections

Well this learning reflection is going to be short as spring break got in the way and well I was lazy over the break and didn’t accomplish as much as I would have liked. I will say that this whole experience so far has been decent, but has had its challenges to me. It has taken a while to get to where we are at and when we finally got issues the semester is half over so that is kind of frustrating, but like with anything in life, things don’t always go as planned. We have been working on an issue to do with logging out while you are editing a form and it is not saving your data. The whole team has been assigned to separate parts of this and my part was to figure out the routing to use when it was all said and done. Upon looking into the issue though I cannot do the route until someone else does their part so I was kind of at a standstill in a sense. I have become more familiar with the projects code though and I happy about that. After discussing the issues we found out that we were looking at the issue wrong and were now waiting on the folks at ampath to get back to us. I will quote a team member as to what we need to work with no, “So the actual problem with the code is that the confirmation dialogue is being run asynchronously using an observable. Which means as soon as the observable is made it is being returned regardless of whether you have clicked accept or not. Which means the value that’s returned by canDeactivate is neither true nor false which is what glitches out the routing. Supposedly, if you make the return value of canDeactivate, Observable<boolean> it’ll wait for the returned Observable to complete before judging the activation but for some reason that’s not working.”

So what initially seemed to be straight forward has proved to be a bit more challenging as we get further into the proverbial can of worms and are now trying to come up with a plan of attack at this. I like how this is unfolding though as I am learning a lot even though it doesn’t seem like we have done a whole lot we are still learning about what problems and issues can arise while tackling a bug and the process of working together as a team as well as using electronic communication and the various tools at our disposal to solve the issue. I am confident that this issue will be solved now that we have a direction to go in and I am looking forward to tackling the next challenge. We are going to be pairing up and doing some pair programming for the next issues. I have never done this in practice and am looking forward to it. I have read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

The Software Craftsman: Chapters 5 & 6

Chapter 5 covers the topics of trying to be a hero and having goodwill as a software developer. The author highlights many of his previous jobs where he was extremely overworked, forced to meet unrealistic deadlines, and worked on large scale projects without any client interaction. These are all definite no’s for a software craftsman. The first lesson is learning to say no. Over working creates bad code which is bad for developers, managers, and clients. A manager can’t be allowed to dictate impossible tasks. Development teams need to stand their ground on what can realistically be done with a constant communication flow to managers and clients. When a developer has to say no, they must provide alternatives or suggestions to the problem. Developers must always be clear about what can get done and any concerns should be addressed as soon as they arise. Keeping transparency with managers and clients allows everyone to work as a team to deliver the best product by a deadline. Also, managers should work as part of the team, facilitating workflow and protecting their developers from external pressure.

After reading this chapter I would definitely have to give the author credit for sticking it out as long as he did at some of his past jobs. I can’t imagine only a few hours of sleep in a car and then back to coding especially with no overtime pay. That is clearly abuse of power by the employer and should never be allowed anywhere. One point the author mentioned that I liked was if you deliver every time you say yes and commit to something, saying no will carry weight to it. I also agree with giving options and alternatives when saying no. A flat no provides no explanation or workaround and isn’t a sufficient answer. Basically from this chapter I will take away the points to not get overworked and always stay transparent with the workflow to both managers and clients.

Chapter 6 covers the topic of working software. The author reminds us the Manifesto for craftsmanship values working software over comprehensive documentation. He then makes the argument that programming is like gardening and that code must be maintained. If code is left to rot, implementing features and changes becomes a bigger task as time goes on. The author mentions that this rotting code is usually the product of developers self-imposing time constraints and pressure on themselves to accomplish tasks quickly. One way to avoid the rotting of code is to practice Test Driven Development from the start and automating testing. That way tests are always written for new code and they can be easily run on top of the old tests. He also mentions how many developers tend to shy away from legacy code because of the frustrations it brings. Instead of focusing on the headache legacy code presents, it’s advised to pick apart small bits and improve them, writing tests along the way. By piecing small bits of legacy code into an upgraded format, huge improvements can be made over time. Lastly, the author makes the point that the cleaner software is kept, the greater lifespan of an application and the greater return for the client which is always the end goal.

After reading this chapter I think there are some good points to take away. First I liked the author’s approach to legacy code. Rather than complain and avoid it, take it as a challenge to improve the code and implement new technologies and tools. While I would still like to work on a project relatively young in development I will keep this positive outlook of legacy code bases in mind. Secondly, I think it’s clear by now that TDD and test automation are best practices in software development and are the way of the future. They have shown up in almost every book covered at this point as well as emphasized by Robert Martin. In summary, my biggest takeaway is to remember to always maintain and improve my code as an ongoing process and take the time to do it right.

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

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.

Sprint 6 reflections

Well this learning reflection is going to be short as spring
break got in the way and well I was lazy over the break and didn’t accomplish
as much as I would have liked. I will say that this whole experience so far has
been decent, but has had its challenges to me. It has taken a while to get to
where we are at and when we finally got issues the semester is half over so
that is kind of frustrating, but like with anything in life, things don’t
always go as planned. We have been working on an issue to do with logging out
while you are editing a form and it is not saving your data. The whole team has
been assigned to separate parts of this and my part was to figure out the
routing to use when it was all said and done. Upon looking into the issue
though I cannot do the route until someone else does their part so I was kind
of at a standstill in a sense. I have become more familiar with the projects
code though and I happy about that. After discussing the issues we found out
that we were looking at the issue wrong and were now waiting on the folks at
ampath to get back to us. I will quote a team member as to what we need to work
with no, “So the actual problem with the code is that the confirmation dialogue
is being run asynchronously using an observable. Which means as soon as the
observable is made it is being returned regardless of whether you have clicked
accept or not. Which means the value that’s returned by canDeactivate is
neither true nor false which is what glitches out the routing. Supposedly, if
you make the return value of canDeactivate, Observable<boolean> it’ll
wait for the returned Observable to complete before judging the activation but
for some reason that’s not working.”

So what initially seemed to be straight forward has proved
to be a bit more challenging as we get further into the proverbial can of worms
and are now trying to come up with a plan of attack at this. I like how this is
unfolding though as I am learning a lot even though it doesn’t seem like we
have done a whole lot we are still learning about what problems and issues can
arise while tackling a bug and the process of working together as a team as
well as using electronic communication and the various tools at our disposal to
solve the issue. I am confident that this issue will be solved now that we have
a direction to go in and I am looking forward to tackling the next challenge.
We are going to be pairing up and doing some pair programming for the next
issues. I have never done this in practice and am looking forward to it. I have
read enough on it and it seems like a good way to do things.

From the blog format c: /s by c-braley and used with permission of the author. All other rights reserved by the author.