Monthly Archives: March 2019

Apprenticeship Patterns: Craft over Art

While forms of craft and art may seem similar to one another, sometimes it is important to note the distinction. This is the exact distinction that Craft over Art outlines in Chapter 3. The point is that crafts have utility, and works of art are made for beauty and reflection. It’s important that, if you’re crafting something, that you treat it that as it is meant to be treated — because it is something that may be used in the future by someone else. Sure, there is room for artistic expression in your craft, but they shouldn’t be anything more than decorative or stylistic touches. As they point out in the book, craftsmanship is built on relationships. It’s about delivering value to a customer and using that to earn your living. Art is usually something that comes from a very personal, self-reflective place that others may connect with. “After all, there’s no such thing as a starving craftsman.”

I like this pattern because it encourages the reader to focus on doing something useful as opposed to something beautiful, as stated in the action paragraph. I feel as though this is important because as of late, I’ve been focusing on this a lot myself in anticipation for upcoming coding interviews. Although I may not be working on things I find myself feeling extremely passionate about, I do feel happy working on what is expanding my skill set. Practicing the language fundamentals of both Java and C, doing interview-style questions, and my independent study have been a blessing in terms of knowledge and learning. They’re all things that will allow me to push the boundaries of my skillset for my future projects.

I will disagree partially with one thing about this pattern, though. I feel as though with the degree that web development, specifically front end, revolves around design choices, that programmers with an artist’s mindset have become extremely valuable. With the amount of emphasis placed on good website and app design, there is absolutely a place for those programmers who seek to make beauty with code where there may have been less of a place for them in the past. Granted, these are UI/UX designers who are partaking in a craft themselves — their art has utility and is meant to be used by others.

Regardless, I found this pattern fairly interesting as a reflection of what programming is and what it is meant to be. Placing yourself in the mindset of a craftsman makes a world of a difference (at least, to my geeky brain) in terms of how you should conduct yourself in the work environment.

From the blog CS@Worcester – James Blash by jwblash and used with permission of the author. All other rights reserved by the author.

Apprenticeship Pattern “Nurture Your Passion”

In this week’s post, I will be discussing the apprenticeship pattern “Nurture Your Passion,” as presented by Adewale Oshineye and Dave Hoover.
I chose this chapter because I think I have felt like I’ve been just getting by for a while now. The  problem it identifies as, “You work in an environment that stifles your passion for the craft.” I don’t think that’s quite fair to my school or professors. I think that in any discipline, if someone is only studying for the tests or working on the assigned projects and calling it a day when they have passed them in, they are not truly adopting the apprenticeship mindset.
Without a constant push forward, I will stagnate. I may get an “A” on the exam or project, but if I forget the material the next day, there is no point. The pattern suggests finding something that sparks interest and pouring myself into it. I have been wanting to do this for a while, but I have made excuse after excuse of not having enough time. The next sentence in the book says “consider putting in extra some time.” It often feels that is easier said than done.
I am reminded of the quote in the beginning of one of the chapters from this book by CS Lewis.  There should be no excuse for starting work. “Favourable conditions never come.” I got very little done over winter and spring break, and I won’t start the next break if I don’t start now.
The pattern goes through some other patterns and notes their relevance. I have blogged here about a few (e.g. “Kindred Spirits”), and a few others piqued my interest, so I read a few of them as well. “Breakable Toys” seemed particularly interesting. I may write here about it in the near future if another pattern doesn’t catch my eye.
I really liked the action. It was while commuting to work, think of three positive ideas to talk about, and when feeling down, shift the energy to one of the exciting ideas. They say this is to avoid getting dragged down. Furthermore, on the way home, they say to reflect on how successful the day was, and think how to improve my environment.
I like how this is a very achievable action. It doesn’t require me to spend any extra time on it. I commute to and from school everyday, and it will likely be the same when I start in the workforce. More often than not, I am already thinking about this sort of thing already, but in a different context. This will be a very natural thing to shift my way of thinking. I could see myself implementing this from here on out.

From the blog Sam Bryan by and used with permission of the author. All other rights reserved by the author.

B10: Sweep The Floor

          The “Sweep The Floor” pattern is described as a way be able find your place on a new team that is unsure of you. This pattern expresses how to find a way to earn your teams trust and contribute to their work without getting in their way. A good way to start is to volunteer to do simple tasks to show initiative and competence for small tasks to eventually work your way up to the big ones. An important fact to remember is to go for quality of work rather than quantity to ensure your teammates of how seriously you are taking this opportunity given by them. This may seem like a step back from all the studying and preparation you’ve done to get to the point, but you must also remember that now you are hired to be on this team. You must prove yourself before they can put any sort of trust in you and the best way to do that without causing any accidents are smaller tasks. This does not mean that you should let the team see you as the pack mule for meaningless tasks, but rather someone who can pick up the slack if needed.

         I found this pattern to be a great introduction to read before really starting out on a team. It allows an easier incorporation to the team dynamic and earn a teammates trust. It created a good sense of what to do and not to do so as to make sure that you are doing extra work for the good of the team while not becoming a pack mule. I want to start using these skills and think that they will definitely make working in a team easier. I think it will make the workload harder, but it seems to be a good trade off to earn the respect for other teammates. I agree with this pattern for that very reason because respect is a very big deal in teamwork. Every team member should prove their skills and respect for the good of the team. I want to continue this practice to make sure that my dedication and commitment to the team is seen to create a better bond with teammates.

From the blog CS@Worcester – Student To Scholar by kumarcomputerscience and used with permission of the author. All other rights reserved by the author.

Kindred Spirits

Week 9

My blog post this week will be on the Apprenticeship Pattern labelled “Kindred Spirits” which encourages the reader to seek out others with the same goal in software craftsmanship. This pattern applies to those that feel the current organization that they are in does not share the same goals as that individual; increasing his or hers software craftsmanship. Instead these organizations can be focused on one thing, getting the product out to consumers. Instead of letting this focus of the organization affect you, you have to seek out others with your same passions so that you can keep your own. The two stories the author uses I feel is a good example of showing how, despite either living on the other side of the country or from completely different organizations, finding a “Kindred Spirit” who shares the same goals of learning as you can be exactly what most people need. Something else that I like that the author points out is the dynamic of having a mentor, where if they start researching a new method or language, you as the apprentice may feel you need to follow suit and drop what you are learning. However, with a community of “Kindred Spirits” you are not obligated to follow their same paths but just to learn from them and show what you have learned in your own studies. One final thing the author points out that I think people forget about to often is the idea of “group-think”, or thinking about a problem as an entire group entity. The author makes note that you as the individual need to be able to still retain your own thought, and the ability to ask critical questions and not just go with the group answer. I like this particularly because I notice that I do this myself, when arguing with friends or work colleagues. People are far too often set in their own decision and I feel, from personal experience, it is always helpful to have someone there acting as the “devil’s advocate”. Even though I might not agree with some of the points that I am making, it is critical to be able to acknowledge and understand other viewpoints or ideas. Overall, this pattern to me highlights the benefits and encourages the reader about finding a community of like minded software developers to bounce ideas off of, as well as seek mentoring when you may not be finding the right mentoring at your current organization.

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

Sprint Review #3

Hello and welcome back to benderson’s blog! I know I posted yesterday but I recently finished another sprint in my software capstone class and thought that you would like to hear how it went, what we did and what are trying to do for our next sprint. Let me start off by saying that my teammates are very hard workers and great teammates for this class, I couldn’t ask for a better team to work with. This last sprint we had was good for the most part, some tasks weren’t completed but we made good progress on most of them which gives a good start for our next sprint.

Let me talk about what we did this sprint. We first decided that to get the most work done, we should split up the work a little bit and have people working on individual tasks to do for the sprint. Nick was working on coding a back end to the Libre Thea food pantry and getting that squared away so we could move forward after that and get more answers from our client on what they want. Nick even has a working mock up on Stack Blitz where it has the form that the client showed us that every person has to fill out once they go into the food pantry to take out food. Johnny was working on the database side of the project where he made a whole hierarchy of the database, what we need to include in the database and he even made a mock up one online with an application we used last semester in a database class. Andy was working on code for the REST API for the food pantry and was making great progress on it last time we checked up with him. Andy has also been working with some teammates from the other class that are also working on the food pantry to get the task done as efficient as possible. Nate was working on the CSS of the project where he was making it look pretty and having the Worcester State colors on it and it looks pretty nice so far. I was working on making sure we have everything set for this sprint, making sure we didn’t miss any features and I was also trying to code up a little mock up myself but I just let Nick do that since he was making a lot more progress than I was. After I thought my task was complete, I tried helping Nate with his CSS work on the program. This sprint went by pretty quick it felt, I think we missed some classes but Im not exactly sure. As I said though, we made some good progress on the tasks we had set out for this sprint and are hoping to complete what is on the backlog by next sprint so we can be closer to the final product at hand. That is basically all we did for this sprint this time, next sprint Ill make sure to write another review and let you know how it went. Thank you for joining me again today, have a good one!

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

Sprint Reflection 3

In our third sprint, we ended up having to revisit some of our previous work and recreate it, but better. After having a lot of difficulty with the previous way of doing it, using some old code from an old project, I decided to go with a more structured approach and read the guide on making template driven forms on angular.io. This guide was incredibly helpful in creating the form, as it has step-by-step instructions, example code and is very descriptive in the how’s and why’s of doing things.

Using the guide and their code as a template, I began to customize the intake form to the necessary specifications. I pretty much tried to recreate the “Thea’s Food Pantry Intake Form” given to us by the food pantry representative. I had to make different types of input for the text and the button input, and this time I was able to get some error-handling working, such as required certain fields before submission. Instead of using WebStorm as my IDE this time, I developed everything on Stack Blitz, a free online IDE and Angular editor that displays your application in real time. It was really useful to use, and hopefully once our group figures out its intricacies and how we can use it to collaborate within it, we can use it more in the future.

I was able to use some of the lessons learned in my Software Process Management class to make sure I maintained the clearness and readability of my code as well. I tried to use good spacing and white-space in the form so that it is clear where one module of the code ends and another begins. I also tried to keep my names both clear and consistent, so that variables containing the same information are named the same throughout the program. This is an issue that caused me much confusion last semester when I was developing a different web based form.

A unique issue I ran into while making the form was the compiler getting confused about the format Student IDs at Worcester State University have. Because my ID number is “0662077” the compiler kept thinking I was trying to use an octal, which would be something like 0x662077, and would not compile. I had to accept the Student ID as a string instead of text to fix this issue. Another issue with accepting Student IDs is that the program tries to get rid of unnecessary 0’s, which ends up making my ID Number different from what is desired. It took me a while to solve this issue, as I had no idea what was going on at first, but it was interesting to see how it could misinterpret my input data because of a preceding 0.

Overall, this Sprint was relatively productive for me, and I hope to continue going forwards. I have to find out what my next goals and challenges are and figure out what I’m doing next. Hopefully it will be something I’m familiar with.

From the blog CS@Worcester – Let's Get TechNICKal by technickal4 and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective 3

This sprint we ultimately ended up with choosing to work on the server. This server would be responsible for handling data transfers between all of the components of the groups. Our group had an internal vote between working on the server and working on the bottom navigation component, we all agreed to work on the server as we wanted to challenge ourselves and learn something that we have not done before. Learning something new seemed to be in the interest of all of us, and especially myself. Whether or not we can do this or not will be interesting because no matter what I feel as though we can learn something as a team.

When dealing with a servers it is very important to understand how services work. A server provides services to one or more clients and a server is the computer. These services are what makes these servers available on the network. In order to understand how these services work, our grouped delved further into this topic. We searched through ampath and found the folders that contained these services. These are the services that we will need to recreate in order to make the other components work. The catch was that we only needed to find the correct ones for each team’s respective component. We came across what is called “nock” to help us with mocking components. Instead of pulling data from servers, instead we need to pull data from a predefined list of attributes somewhere in the code. This is precisely what nock is designed to do. It overrides node’s http.request function to use modules directly.

Now that we have established what we are going to be using to mock these requests, our task was to now pinpoint these services. We started a backlog of services that we needed and plan to consult with other groups to see what type of form data is needed so that we can find the respective services. We have been communicating using slack, not only with our group, but with other groups to see where their progress is. We also created designated channels for discussion about pinpointing these services that we need to mock the requests. So far, nothing has really started for us as a sort of production, however in the coming sprints we want to start really engaging more with other groups and want to start designing the basic frameworks. This server seems like a big deal, and if pulled off correctly will be great. Trying to build and design something that is brand new to you is very intimidating and possibly time consuming, which is also part of the reason why we are trying to educate the other groups to have them help us find what specific services they need to we can work along side them to have a smoother transition when it comes to mocking the data. Hopefully we will be able to start gathering the resources and information we need by working with these other groups to secure these services and hopefully correctly map their locations.

From the blog CS@Worcester – Amir Adelinia's Computer Science Blog by aadelinia1 and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective 3

 

This past sprint not much has progressed since the last sprint in all honesty. Since the last sprint we were given a few new details onto what we are going to be doing exactly for this project. We discussed the matters as a team going into some of the files, we were originally given from the ngl-2 repo. As the sprint went on we talked about what are task should be. We had ideas of what we wanted to pick for our team role. But never really solidified our decision only verbally talking about what we wanted.  We know what needs to be done or rather what the final product should be looking like. So now we will begin to start actual work on the project it would seem. With each team working on different problems like setting up a mock server and so forth. In short not much has really changed since last sprint retrospective but I personally feel we are a step closer in the right direction than previously. I am looking forward to working on this project with my team as we get closer to an end product.

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

Sprint 3 Retrospective

Since the last sprint retrospective, we have all finally begun to get an idea of the actual work that we are going to be doing. From the videos that were sent to us that we watched, it seems to be the case that we are going to be implementing some front end components like HTML forms and buttons using angular and javascript or typescript. Even with this in mind, though, we still have not begun writing any actual code yet. We are still in the stage of figuring out how to start on this project. Part of what was described in the videos included what appears to be an already functioning template of buttons and components that interact with the page but have no backend functionality, so my assumption is that we are expected to take this design and program the buttons to read the forms and pass the information to some function that sends it to a database. I am anticipating that we are going to need to read some of the existing ng2-amrs code so that we can have the frontend invoke the right functions written on the backend. This is all in my imagination, though; we are still not certain enough to know that that is what we are going to be doing. After trying to access the wireframe designs from the videos, they do not seem to exist in HTML – they are possibly just a graphical simulation of how they should interact. If this is the case then our work will begin first with building the pages and placing all of the components on them how they appear in the wireframe.

I think things would be moving more quickly if all of the groups were communicating more about what everyone plans on doing, since everything is going to need to be divided among the groups, and then within our group we will need to divide tasks further among ourselves. Firstly, though, we need to understand the goals better in order to be able to come up with smaller tasks to break them into so that we can work on separate pieces of it individually, then bring it together as a group, and then bring each group’s contributions together to complete the project. Progress in this regard seems to be happening very slowly. We have a vague idea of what needs to be done and we do not know what comes next, so until a lot more detail is figured out, there is only one thing to do, and that is to clarify what needs to be done and come up with some more things to do so that the work can be performed in parallel by multiple teammates.

At this point it seems like the groups have decided on one particular thing to focus on, and our group is focusing on one particular component of one page of a wireframe made in Zepplin that was demonstrated in the first video. We do not know what we are doing, but we are making progress.

From the blog cs-wsu – klapointe blog by klapointe2 and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective – Round Three

A reflection on what I learned from
this week’s activities is that sometimes it’s best to restart. Our initial two
sprints brought us up to a point where the current delivery is usable but could
not be built upon. We had trouble trying to incorporate features from each of
our own work loads that was divided in Trello. The main issue from the scrapped
delivery is that it is written in Java and missing fundamental components that
would make it difficult to create a webpage with. As such, the problem resolved
after deciding to focus our efforts on Angular and using it’s features to make
our lives easier.

Another lesson learned from this week’s
activities is that having more than one repository between two GitHub and GitLab
is a nightmare. It was a mix between each of the members uploading to our own
repositories to share mockups of things we have created during the sprint. This
choice is backed by us not feeling up to upload mockups directly to the repository
made by the professor since we weren’t “feeling ready” yet.  Then there is the issue with having two different
food pantry repositories which further confused everyone. However, this issue was
eventually resolved when the professor and some students came up with another idea
for handling the repositories. The new system creates a fork from the main
project to the class repository. There are a couple other things mentioned
about incorporating “stories” using this setup that I have yet to fully
understand.

The third lesson learned from this
week’s activities, is that it is very easy to get lost and sidetrack from the
main goal. This lesson is mainly for myself as I was working on the database
but took me an entire sprint to realize that I was working on the wrong portion
of the project that was unneeded at the moment. Focusing unnecessary resources towards
a feature that should be left for later. The other members were focused on the
intake form and had created the front-end of it but needed a place to store the
information later on. This is the area I should have tackled, in which our
members would have been working in unison.

During this sprint, I focused my efforts on mainly establishing a connection to the SQLite database created from the previous sprint with the current project. Using JAVA and the available JDBC library found on the web, I was able to successfully connect to the database. However, when it came to transfer what I learned into the main project we were working on gave plenty of errors. There were missing libraries and many unused and preplanned files that needed deletion. Although this was a problem, the next problem is mentioned earlier in the blog. We needed a clean slate to work with since the project was in an unworkable state. After we got back to the point where we were in JAVA, now in Angular, I had to find a new way to get the SQLite database to work in Angular. Now that we are back on track, I can see where the project is likely headed!

References:

http://www.sqlitetutorial.net/sqlite-java/sqlite-jdbc-driver/

From the blog CS@Worcester – Progression through Computer Science and Beyond… by Johnny To and used with permission of the author. All other rights reserved by the author.