The Software Craftsman Book Chapter 5 & 6

The difference between craftsmen and average developers was beautifully summarized within chapters 5 and 6. Developers are just people who write code. Craftsmen, on the other hand, are gardeners. And just like a gardener, craftsmen constantly tend to their code, making sure everything is working properly, and making the code clean and clear for other programmers to read. As simple as the concept of being a craftsman as opposed to a developer is, most programmers still do not strive to be one. I believe that because of that, we run into some many avoidable problems. “We don’t write bad code on purpose but we are constantly trying to find ways to justify it.” This sentence from chapter 6 perfectly expresses how I feel about the situation and honestly, I agree. Not even talking about computer science, I think that that quote can be applied in all aspects of our lives; we make excuses for things we want to do but “don’t have time for”.

From the blog CS@Worcester – Tan Trieu's Blog by tanminhtrieu and used with permission of the author. All other rights reserved by the author.

Sprint 4 Reflection

Another sprint down in the books and this was a pretty tough sprint. There was a major road block that was in the way with the progress of our issue. This road block was called spring break. During spring break, I did not work on our issue at all. Before our break, we were assigned an issue, but we were not able to fix it. Our team reached out to the AMPATH maintainers, but they did not reach back to us. Thus, we were then given a new issue. Since we were given a new issue a little before the end of the sprint, not much was done. However, a new sprint is coming and I’m excited to work with my team on getting this issue resolved.

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

The Software Craftsman Ch. 3 and Ch. 4

For this post I read chapters 3 and 4 out of Sandro Mancuso’s The Software Craftsman.  In these chapters Mancuso breaks down what he means by Software Craftsmanship.  First and foremost a Software Craftsman is a professional who is constantly learning new tools and techniques.  In chapter 3, “Software Craftsmanship,” Mancuso presents and explains the Software Craftsmanship Manifesto:

Not only working software,
but also well-crafted software

Not only responding to change,
but also steadily adding value

Not only individuals and interactions,
but also a community of professionals

Not only customer collaboration,
but also productive partnerships

The second piece of every part of the Software Craftsmanship Manifesto simply elaborates on the first piece.  This is very different from the Agile Manifesto which contains contrasting ideas.  In this way, the Software Craftsmanship Manifesto seems almost intuitive.  For example, take the first piece, “Not only working software, but also well-crafted software.”  The next logical step from working software is software that is well put together.  In TDD after you write a test, you write code that makes that test pass. Then you write another test, and more code to pass that test.  Refactor and repeat.  Using this technique you write not only working software, but as you progress, the software becomes well crafted.  So I guess I can understand someone feeling as though they need to lay out these guidelines, but as these techniques have developed over time, the aspects of the Software Craftsmanship Manifesto seem almost inevitable.

Chapter 4 is entitled “The Software Craftsmanship Attitude.”  This chapter is essentially a recap of The Clean Coder in its entirety.  Instead of going through all of the content of this chapter, I would like to refer you to my previous posts.  After reading this chapter, and without having read the rest of this book, I would think that simply reading this book would cover most of, if not all, of the pertinent information from Robert C. Martin’s The Clean Coder.  I think that the overlap is probably pretty substantial.

From the blog cs443 – TayNock's Blog by taynock and used with permission of the author. All other rights reserved by the author.

The Software Craftsman Ch. 1 and Ch. 2

Fitting that the last chapter in Robert C. Martin’s The Clean Coder was about craftsmanship, now we are reading The Software Craftsman: Professionalism, Pragmatism, Pride by Sandro Mancuso.  I’ve read the first couple of chapters of Mancuso’s book and I’m not sure if I like this book any more or any less than the previous one.  I suppose that is fortunate.

The first chapter was titled “Software Development in the Twenty-First Century” and this chapter is about as long as the title.  Chapter one was all of six pages long and served only as an introduction to the rest of the book.  Mancuso did discuss the idea of seniority in the field of software development and broached the topic of Agile, the topic of the next chapter.  There wasn’t really enough content to reflect on this particular chapter.

Agile!  I love it, I LOVE it.  I’ve read and heard so much about the Agile process in the past year, and aside from the fact that its the direction businesses are moving, it just makes sense.  I’m pretty sure I have blogged about Agile before, but if not, I’m happy to do it again.  Most importantly we need to include the Agile Manifesto:

We are uncovering better ways of developing software by doing it and helping others to do it. Through this work we have come to value:

  • Individuals and interactions over process and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more.

This is just a better way of handling projects.  Using an Agile framework, ie. Scrum, and keeping in line with the Agile Manifesto companies are able to produce software more quickly and with better quality.  Agile reduces errors, misunderstandings, and obstacles by introducing more communication.

From the blog cs443 – TayNock's Blog by taynock 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.

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.