Category Archives: Capstone

Use the Source: how to numb your mind faster than a lobotomy

Perhaps it’s just naturally a trait of mine, a coincidence growing up, or perhaps I more broadly reflect societies supposedly shrinking attention span; regardless of the cause, I have very little patience for reading documentation. Instead, I often like to open a sample project, usually the placeholder created by default, and see what happens when changing things around, or how information is passed between files. As such, I oftentimes find roundabout ways of completing tasks in a new language or framework. This results in less than ideal code, even if functioning, that does not follow best practice or any convention the language/framework may have. So therefore, the “Use the Source” spoke to a weakness I have in software development.

It states that one should choose a complex, and necessarily open source, project in the language you are hoping to learn to fork and pore over. In doing so, one can internalize as many of the lessons this code may have to teach, the ways experts write in this language, the “tricks of the trade” if you will; and, as a result, be inspired to apply these concepts in ones own project. This unfortunately, sounds terribly boring. It’s hard enough for me, and many other students I know, to pick apart our own code only months after writing it. I can’t imagine trying to parse years of work by developers with an incredible knowledge of their chosen language. This seems like a recipe for frustration. I could easily see a student not unlike myself throwing themselves at a new language in this fashion and coming away discouraged and maybe even completely overwhelmed; to the point where they may shy away from learning that language at all.

Instead, I would propose a healthier middle ground. I find that in messing with the code you can find little victories where your exploration paid off – victories that, for myself at least, keep me motivated. However, as mentioned previously, learning completely on ones own may waste valuable time and internalize bad or inefficient habits. As such, I think one should push their abilities as far as they can manage, then seek guidance from communities online. There exist thousands of YouTube tutorials and stack overflow threads where more than one solution is reached to nearly every problem; so, unlike the open source project, you can pick a solution that has a logic you understand best and can implement. I may have no patience to dig through years of documentation, but I don’t lack the patience to instead experiment and ultimately learn the language/framework.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

Kindred Spirits: Programming inspired by Anne of Green Gables

When reading the kindred spirits apprenticeship pattern, I was immediately reminded of my first real programming class, CS140, wherein I met some of the friendly faces I would spend the next two years becoming a programmer with. A few of these faces were a part of my group in that class’s lab and with them we challenged each other in the subject and helped fill each other’s blind spots. While this is hardly unique, I’m sure, it exemplifies what the pattern is all about: finding peers who you can learn and grow with. Now with those two years nearly behind us and the end (of our education) is in sight, those same friends have been amazing resources.

As new learners, we tend to go in all different directions, not favoring any set method because we have yet to find the path of least resistance or best practices. Subsequently, we create puzzles pieces with our bits of knowledge that we all can combine to get a clear picture of a language, framework, et cetera. I have found as well, that what was often very useful was the ability to politely disagree – read: bicker like an old couple – with your peer and push back and forth on each other to really challenge one’s knowledge or understanding of something. It was through this back and forth that many of the solutions we were so desperately searching for came about; which is something the pattern even addresses, stating that it is imperative to avoid group think and challenge each other.

I remember distinctly have an erratic mass of code segments and illustrations of a particular data structure, the exact one I cannot remember, all over the board in the Science and Technology center study rooms. Data Structures, our major’s trial by fire, has crushed fledgling programmers of far greater skill than me. I can say with no doubt, that had it not been for these brain-storming sessions I would not have passed that class or even completely the projects thoroughly in the way that I eventually did. As I look forward to internships and even jobs after graduation, I hope to keep those around me who I have learned so much from and find new kindred spirits to take on this next chapter of my programming career.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

Craft Over Art: or how I learned to stop worrying and love my ugly UI

As I mentioned last week, I have a tendency to try to make products out of projects; meaning I can’t just have something to tinker with for fun, it needs to essentially be a rough draft for the actual project I have to work on. In the same vein, I have another hang-up on wanting things to be clean and pretty to start. Now, of course, one should strive for well formatted code following best practices, but specifically for those projects with a user interface I try to go straight to a finished product from the start. As a result, the Craft Over Art Pattern was illuminating, bringing into focus where my priorities should lie especially in contrast to where they are currently.

In sum, this pattern emphasizes that you have been charged with creating a functioning product, not necessarily a pretty one. The line, “the things we build for customers can be beautiful, but must be useful” says it all. I realize in constantly polishing a project before its feature complete, I end up throwing away a lot of work spent on “dolling up” features or elements of the user interface that may change or not even be used. I even caught myself making the same mistake even on a personal project using a different web application language, where I did not even attempt to make any forms or methods that communicated to the backend, instead spending time adding libraries for user interface elements that look nice and animate well. While there is certainly a place for those things, this pattern helps one understand that is when you have all of the parts of your application finalized.

I should have learned this lesson last semester with my final project. I spent so much time fiddling with the color palette and page animations, that the content on those pages was barren, or poorly formatted. It is nice, I think, that my webpage looks and animates nicely, but when pages break upon reloading then it hardly matters. If there is constantly some expectation of failure with a project, then the font you choose is hardly relevant. I think that is what this pattern helped me realize most about this weakness of mine; utility is the most important aspect of software, everything else is so much fluff.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

Breakable Joys: what I was missing in my breakable toys

As I picked through the list of Apprenticeship Patterns one of the earlier ones jumped out to me, as it seemed fairly obvious from the name what it was. Upon reading the description I was correct in this assumption and further I had experience with this particular pattern – even if outside of an apprenticeship. That description being a “toy system that [is] similar in toolset, but not in scope to the systems you build at work”. If you were to insert “school” instead of “work”, then I have built breakable toys for the same reason the book describes: to try and fail in private so that your successes can be applied to a real project using the same technologies, but your failures do not come at the expense of said project.

I have a sense already that many of the patterns I pick this semester will be those that I either have experience with or involve skills I feel insecure about. This being a pattern I feel familiar with I hoped to see if I was applying it correctly, and I wasn’t, at least not completely. First, the book stresses that a breakable toy should be like any real toy, fun. I think this is at least one hang up I have had with my own toys is that I try too hard to make them into potentially repurposable that I can use in whatever project I am training for. Instead, I think moving forward I will try first to make something fun, but overengineer it like the book says, such that I can gain as much experience possible from some silly little program.

Additionally, the book mentions making a little wiki as your toy, and this I had never thought of. Initially, I had read this as meaning thoroughly documenting the toy you are building. It makes perfect sense and follows logically one of the best points that has been made to me about learning, which is that the best way to do so is to teach. However, upon subsequent readings I realized they meant developing a wiki with your selected tools. While this certainly would help foster an understanding of yours selected tools, it would clash with the previous goal of being fun, at least in my mind. Instead, despite it being a misunderstanding, I think much could be gained from documenting one’s progress on a breakable toy. Considering I have a spike project to work on currently, I think I will apply these lessons as I begin.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

A series of relatively unconnected thoughts about the Apprenticeship Patterns readings

This blog contains mostly random thoughts as I did the reading. Nearly each paragraph is a new thought, but they all build to a whole that is effective strategies I hope to adopt or observations about the way the contents relate to my current place in school and work. Please take note as you read this.

I find it interesting that not only did they take the time to address what you should expect to do as an apprentice, but in outlining how your responsibilities change as a journeyman and eventually master they set you up for what you should expect from your mentors and what to strive for as a mentor. They do make a point of saying it is not their intention to write this book to make effective mentors, but I think despite their protestations it does provide a decent lens for the breadth of experiences, however brief their descriptions may be. While I may still be hardly able to envision my life as an apprentice let alone something higher, I hope to remember at least some of these lessons.

As well, one portion stood out to me very specifically as in the process of writing internship applications I had a cover letter I was very confident in, but realized that I could come off as too confident in it and had not emphasized my willingness to learn and accept new techniques. As a result, I will be going back to revise that letter again.

Unsurprisingly, much of these introductions is spent telling you to get out of your comfort zone for a deeper learning experience, but this should be understood innately, so it feels redundant. However, one good idea was to pick up a lesser documented language and try to write the documentation on your own. You could even do this exercise with an already well-established language to solidify your knowledge of it. In fact, more than just languages this is a great idea for any subject, as the old adage goes: “the best way to learn is to teach”. I have found for myself that tutoring a class while here at school was an amazing refresher for the material that I had forgotten since I had taken it so long ago and I picked up new knowledge that I had missed previously.

One thing that did confuse me a little was these chapter’s seeming insistence on remaining a developer rather than moving on to a leadership position or some other “higher ranking” position. Or rather, the utility of this book to those who wish to remain in software development, which makes a little more sense. With the mention of difficulty in keeping or finding good developers, despite a deluge of mediocre ones, made me worried about proving I am worth hiring or having a team that is uninvested in the work or does not possess anything close to mastery over it.

I was particularly struck by the quote at the beginning of Chapter 6, as I have a lot of trouble finding personal motivation without the structure and reward of grading found in school. Therefore, the advice of keeping a reading list is very pertinent to me as perhaps one way of building my own internal mechanisms for remaining engaged in my field and becoming self-motivated.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

Beginning of the End: Software Development Capstone

This feed will contain blogs for my aforementioned Software Dev Capstone course, as it did for the courses I have taken previously. I’m excited to share my experiences in class as well as reflections on the reading materials this spring semester.

From the blog CS@Worcester – Press Here for Worms by wurmpress and used with permission of the author. All other rights reserved by the author.

New Year, Same-mi

cs series (17)Hey guys, here’s to another (and my last) semester of this CS series of blog posts!

Hopefully you will HIIT–or should I say reach–all of your professional and personal goals for this year. There’s so many things to always keep improving on but it’s always easier when you break things down to smaller changes or achievements.

Here’s a picture of one of my personal goals as can be seen in my university’s Wellness Center:

Processed with VSCO with hb1 preset
“This Year I Want to ______”

One day I will be able to get up there without being lifted…alright I’ve gotta get back to practicing my jumps.

Best of Luck,

Sami

From the blog CS@Worcester by samanthatran and used with permission of the author. All other rights reserved by the author.

Capstone: Sprint Reflection 6

Sprint 6 was the final sprint of the semester. We rounded up this sprint with an unfinished solution to issue APTS-254. Over the course of this sprint, we were feeling really good on our understanding of this issue. We required quite a bit of clarification from the Ampath team. After getting some really good clarification we found that the code we needed to work on was in an entire different directory from the one we had been previously working in. Once we finally found where we should be working, we began digging in deep into the issue. The first thing we noticed is that this issue was associated with their ETL server implementation. None of us on the team had previous understanding of what an ETL server was so we I did some digging. I found a few resources online (Here’s a good brief description) that I summarized for the group. The idea was fairly simple, except the way the Ampath team was using ETL was basically by skipping the Load portion and just passing the transformed data to the end user as a notification.

I had a really good understanding of the issue at this point and even began writing some code that I thought might work for this specific issue. Part of the major issue that stopped us from being able to test this solution was the fact that we were unable to test that our solutions actually worked before committing changes. In order to test our solutions we were going to need a running ETL server. In the end I was kind of bummed we weren’t able to resolve another issue before semester’s end. But I felt good in the things I learned from trying to resolve this issue.

I would love to continue working on these issues in the future but with all my personal projects and the fact that I will be starting a new job (as a Software Developer) on the 22nd, I don’t plan on having a lot of extra time. All in all I really enjoyed working on Angular 2 and seeing how a large scale project like Ampath was built.

From the blog CS@Worcester – Tyler Lundstrom by CS@Worcester – Tyler Lundstrom and used with permission of the author. All other rights reserved by the author.

Capstone: Sprint Reflection 5

This previous sprint was quite a successful sprint. We successfully had our code accepted into the Ampath project this previous sprint! It took us a while to get the understanding we required for the issue, but once we fully understood the issue it only took the team about a day to come up with a valid working solution. Once we as a team had decided to create a pull request, I went ahead and initiated this task. The biggest speed bump we hit for sure this sprint was getting the fix officially accepted and pulled into the project. The Ampath team had a specific set of guidelines they would have liked us to follow, we were not aware of these guidelines to begin with however. The first thing we needed to do was officially have the Ampath QA team checkout our fix and run it against their test systems. Then once that occurred once more developer was required to test the fix and check the quality of the code being applied to the fix. Once this was done our fix was accepted.

The second phase of Sprint was information gathering for the next issue we are working on. Towards the end of the sprint we received clarification on the issue and we have found that this may be a trickier issue then we initially thought. We are excited to get working on this issue this sprint, because we would like to see at least one more accepted change from out team before the semester’s end.

From the blog CS@Worcester – Tyler Lundstrom by CS@Worcester – Tyler Lundstrom and used with permission of the author. All other rights reserved by the author.

The Software Craftsman: Chapters 5 & 6

Cahpter 5 resembled Chapter 2 from Robert C. Martin’s book The Clean Coder which has many of the same themes as this book. This chapter mostly covers the fact that as a professional you occasionally need to say no. If you don’t say no when you should say no, things can get ugly quick. I won’t talk too much on the reasons why here because I talked about it in more detail here.

I do want to talk briefly about one thing that was said in this chapter. With good managers, there should never be a “us and them” attitude. This could never be more true and I recently experienced the downside to an “us and them” attitude. I was on a job with the the VP of Stack Testing in Bridgeport, CT. We were working as contractors for a fairly large power generation company, we’ll call them “Big Guys”. So Big Guys have so many power plants that instead of contracting companies like us to do their stack testing, they have an entire team of internal stack testers. However, an issue came up where Bug Guys’ stack testing team didn’t have some special analyzers that my company has. This equipment is very expensive and very complicated to use. So we arrived on site and immediately the upper management of Big Guys made us feel threatened. The upper management made multiple comments about how if we screwed up even the slightest bit that they were going to throw us off site and hire a different contractor. That was the first sign this was going to be a rough few days. Anyways, we ended up meeting Big Guys stack testing team, we’ll call them “Little guys”. All of the stack testers from Little guys were incredibly nice and welcoming to us. They were excited to have us on site and really excited to see our equipment in action.

After a 16 hour day of testing along side Little guys, we started seeing some trends. Big Guys management kept referring to the testing that was happening as “Your tests”(Directed towards Little Guys), like somehow Little Guys are requiring them to test when the reality it that the State of Connecticut was the one requiring THEM (Notice the beggining of the Us and Them mentality). Then we noticed that Big Guys were not giving Little guys any information until the very last second. Each time they did this the sent Little guys into a frenzy getting ready for the next test. Same things like this kept happening throughout the day.

We arrive on site the next day to find out that after the previous day, Little guys were upset and disgruntled about the previous days happenings. They began venting to myself and my boss. The “Us and them” mentality become so apparent when they started go against what Big guys were telling them to do. Towards the end of the second day, Big guys told little guys on their last hour of tests to pause their tests. Big guys eventually told us why they paused the test and the reason was completely strange. They had us pause for reason that were 100% unrelated to what we were doing at that moment. Little guys made a unilateral decision to continue testing so they could leave before 7 pm. Obviously Big guys were furious when they found out and there was a yelling match (Thankfully neither my boss nor I were present for) between Big guys and Little guys. The moral of the story is if they had not had this us vs. them mentality I am almost positive the days would have been smoother and we there definitely would have been less contention.

 

Chapter 6 talks about Craftsmen as gardeners. I really appreciate this visual. There certainly is a difference between someone who plants and someone who gardens. Someone who plants prepares their base, digs their holes and plants their plants and then moves on. If you do this as a gardener then you will quickly find your plants getting choked out by weeds or overgrowing other plants. This is not okay. One of the most interesting points made was the mindset of developers thinking the didn’t have enough time. I never realized it, but I have done this. Multiple times. Working on small projects I could have saved my self countless hours if I had simply taken the time to create unit tests. I see that now. I know that now. But I still don’t always do it. Why? “CAUSE I THERE’S NO TIME FOR THAT!!”. Really? Really, Tyler? Don’t you remember last time you said that? You spent hours debugging a simple logical error that could have been found in seconds using unit tests. ….Yeah, I still skipped unit testing to push features “faster”. This is something I am trying to break for sure and this chapter was a good reminder that it’s a time saver for everyone if I simply write unit tests and take the time.

Guess what, Tyler. There. Is. Time. Write Unit Tests!

I have the written on a sticky note on my monitor at home.

From the blog CS@Worcester – Tyler Lundstrom by CS@Worcester – Tyler Lundstrom and used with permission of the author. All other rights reserved by the author.