This week, I read the apprenticeship pattern “Read Constantly”. Out of all the patterns that I’ve read so far, this is the one that will be most difficult for me to implement. Although this pattern will not be the easiest to implement, I think that I will be worth all of the effort because how much it will really increase your market value. The industry is always changing, and it is essentially impossible to keep up with all of it. There are new technologies coming up, old technologies changing and other technologies becoming obsolete, the most valuable engineer is the one who is aware of most of these changes.

Constantly reading has both immediate and long term impacts on your career. In the short-term you can choose to read material pertinent to you current line of work. This might involve deepening your knowledge of a concept that you’re somewhat familiar with. This reading if done consistently can lead to one becoming knowledgeable of how multiple components come together and interact. If the reading you choose to do is focused on the short term, you may find yourself being recognized by your team as the “go to” guy for a wide variety of question and once that occurs, your value as an employee has rocketed. In the long term, constantly reading makes you extremely marketable. This pattern applied with even a tiny bit of consistency will lead you to having a great understanding of the ENTIRE industry as a whole. Having this general knowledge is already a leg up on the competition, but if you choose to apply and experiment with what you’ve read, you may find yourself comfortable with many different programming languages, frameworks, operating systems, etc. Armed with this acquired knowledge and skill, you now have a solid foundation that can be build on going forward in your career.

The value that this pattern has is evident, there really are no drawbacks to this one at all. The one difficulty with this pattern may be time. It is possible that you find yourself having barely enough time to handle the work that you have, never mind having time to do some extra reading. Even with the time constraint, I still intend to apply this even if I am not reading “constantly’.

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

This week, I will be writing a reflection on the “Your First Language” pattern.  This pattern addresses those are seeking a job in software development but obtaining said job requires a proficiency in a specific language and/or developers who feel comfortable in one or two languages but are expected to maintain the same standard of quality as their teammates/coworkers.  I chose to reflect on this pattern because I am currently trying to obtain a software development internship and most, if not all, of them require proficiency in at least one or two languages.  I do feel as though I am proficient in Java and C, but I am unsure how my skills compare to those that I might work with in one of the internships I am applying for.  I found this pattern particularly helpful in my current situation.

To deal with this problem, Oshineye and Hoover recommend picking one language and becoming a master of it.  They advise developers to spend a few years solving problems in a single language while honing their abilities.  I found this to be useful because I have had the idea, for the past few years, that employers would look for a diverse skillset in novice developers, but Oshineye and Hoover believe that being a master of one language is more useful than being sufficient in many.

To help improve your experience while learning your first language, Oshineye and Hoover believe that it is incredibly helpful to have an actual problem to solve.  I was at this point last year, which is when I decided to join a website that offers free coding challenges that deal with both real world issues and the type of work you might do in school like programming functions in a specific data structure.  They go on to suggest that, in addition to spending a lot of your own time practicing a language, novice developers should find also experienced mentors to aid in their learning.

Oshineye and Hoover conclude the pattern by describing ways to create short feedback loops and use testing frameworks so that novice software developers can easily track their progress as they learn a language.  This pattern has inspired me to ‘master’ a language, find a mentor, and begin creating feedback loops (such as testing) to track my progress.  I think all of these things will give me a sturdier foundation when I enter the field.

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

The problem addressed by this pattern is one that should be familiar to most: needing guidance in unfamiliar ground.  The authors propose that you find a “master craftsperson” to guide you, but recognize a flaw: it is difficult to find true masters in a craft that is still fairly young, and in which the tools evolve very quickly.  Most of all, they emphasize the importance of getting over the anxiety of reaching out, because the upside of success is so high.

This resonates with me and with my experiences.  I find that I am very successful when I have found a mentor of whom I can ask questions and bounce ideas without fear of ridicule or rejection.  Even if my mentor doesn’t respond right away or have the answer, the act of formulating my thoughts enough to send them as a question to someone else can help me find what I’m looking for.

The authors also recommend taking on a mentor role when you have the opportunity.  This is also something that I’ve found helps me learn.  It may be common wisdom at this point, but I’ve found that I don’t know how much I know (or what critical knowledge I lack) until I go to teach it to someone else.  My family members often find themselves in the (hopefully patient) position of listening to me test my knowledge by explaining things to them — doing that by teaching someone that is really invested  in learning the topic is even better!

I can also connect with the anxiety of reaching out, especially to someone with whom I do not have a previous connection.  No matter how beneficial the outcome may be, and no matter what my past experiences have been (overwhelmingly positive) I tend to have trouble taking that first step of making a connection.  In my life in general, the anxiety of reaching out to other people for help is one of the largest obstacles I struggle with and one of the most important for me to work on.

Like with many of the other patterns, I find that this one did not necessarily teach me anything truly novel.  However, it validates what I thought I knew and backed that up, which is just as important.

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

“Practice, Practice, Practice” is a pattern which encourages exactly what you’d expect: continuous practice. Like Breakable Toys, the problem this pattern is intended to address is that failure in your professional responsibilities is too costly to risk. You can’t effectively learn without the freedom to fail, though, and for that reason you need somewhere safe to practice.

This is another pattern in which the writers say the ideal application of it would be in a world with formal software apprenticeship, but in reality, software apprentices have to create an approximation for themselves. In their ideal world, a mentor would assign their apprentice practice based on the apprentice’s strength and weaknesses, reinforcing what the apprentice does well and correcting their weaknesses. The writers emphasize the need for objective metrics to evaluate your abilities as a substitute for this; if you practice without getting feedback, you will reinforce bad habits.

One way of making sure you receive regular feedback is to practice in a way that’s public to some degree. The example they give is a group that meets in person to perform code katas, exercises which are meant to help programmers to sharpen their skills through repetition. For some apprentices, an activity like this probably isn’t practical or immediately accessible. Online communities devoted to practice are another option which can likely serve as a good source of feedback. Importantly, any method of getting feedback on your practice should take place in a relaxed and playful setting, since the point is to remove the stress of mandatory success. The practice itself should be something just beyond what you know you can do easily. In having to struggle with a problem, the practice will strengthen your abilities in addition to providing the benefits of repetition.

This is a pattern that appeals to me, because I’ve discovered that I learn the most by actually writing code. To that end, the writers suggest some older books that teach important programming techniques and design principles through fun problems. This seems like a useful, concrete recommendation, and I might look into obtaining one of their suggested books or find one of my own to improve my coding skills.

From the blog CS@Worcester – Fun in Function by funinfunction and used with permission of the author. All other rights reserved by the author.

In a field that continues to rapidly evolve, staying up to date with the latest and greatest tools and techniques is essential. Complacency is simply not an option if one wishes to remain competitive and relevant in the information technology field. Not surprisingly, however, there are certain tools that we become familiar over time, through repeated use and practice. There is nothing wrong with this, as familiarity with certain tools or techniques allows for more accurate estimations about work, and helps to limit risk. In Hoover and Oshineye’s Apprenticeship Patterns, they present a pattern that helps software apprentices deal with the complexities of complacency titled Familiar Tools.

In the Familiar Tools pattern, Hoover and Oshineye start out by acknowledging how valuable it is to have a set of tools that you feel comfortable using. Not only does this make you more valuable to employers, it makes the work easier and more valuable to the developer as well. From increased productivity to more accurate estimates, familiarity is important in the progression of a software craftsman.

Although the word is never explicitly mentioned, this pattern also seems to issue a warning about complacency. Hoover and Oshineye caution apprentices from becoming too set in a narrow range of familiarity, as that puts them at more risk for becoming irrelevant should the popularity or usefulness of those familiar tools fade.

This pattern was pretty easy for me to appreciate, as I already enjoy learning and improving through personal and professional development. Perhaps this desire to stay ahead of the curve is part of the reason that I became interested in the field to begin with. I have always enjoyed staying up to date with the latest and greatest gadgets, trying out beta builds, and experimenting with technology. Although the context is a bit different in the Familiar Tools pattern, the idea is very similar. The quote by Eric Hoffer that is included in this pattern also spoke to me, it is, “In a time of drastic change it is the learners who inherit the future. The learned usually find themselves equipped to love in a world that no longer exists.”

When entering the computer science program three years ago, it was repeated time and time again that the material that I would learn in college will likely be outdated by the time I am entering the workforce. While this is simply a fact of the computer science field, I feel that I am doing well at keeping myself informed and appreciate the efforts by my educators in keeping my education relevant and valuable in a rapidly changing world.

From the blog CS@Worcester – ~/GeorgeMatthew/etc by gmatthew and used with permission of the author. All other rights reserved by the author.

From the blog CS@Worcester – Computer Science Exploration by ioplay and used with permission of the author. All other rights reserved by the author.

The blog post this week discusses my favorite principle in software development, the open and closed principle. The open and closed principle encourages independencies in software development. It states the following as outlined in the article: Class behavior should be open for extension but closed for modifications. This can be separated into two parts. As explained in the article, the first part is about the behavior of a class. Extensions of behavior allows for changes in behavior to be added, deleted or modified without affecting the other behaviors. This is what is meant to be independent. Thus, the 1st part of the statement signifies changes in behavior which signifies changes in source code. The second part of the statement states that class behavior should be closed for modifications. Is this a contradiction? Modifications means changes to source code, which the second statement encourages developers not to change. This means that class behavior should be independent and not need to be modified when other parts of its behavior are changed. So, when extending a class behaviors, the source codes for other behaviors should not be changed. The other definition introduced in the article is: Software entities(classes, modules, functions, etc.) should be open for extension, but closed for modifications. The explanation for the principle is as I have described previous just above that it encourages independence in software methods.

The article, however, expresses confusion for both definitions because the two sides of the principle is a contradiction, however I think it did a pretty good job in its explanations and examples. As explained in the article, the main idea behind the OCP is that the behavior of the system can change by replacing “entities that constitute it with alternative implementations,” but that the other behaviors can be independent and therefore need not be changed. The example given is that for calculating taxes. As stated, take for example the TaxCalculator interface for calculating taxes. In this system, if we replace the UsTaxCalculator with the UkTaxCalculator, this does not require modifications of existing logic, but that it provides for new implementations to an existing interface. Overall, the main idea is that you can add behaviors to systems be adding new code, but the existing ones do not need to be changed. This creates separability so that system behavior can be easily modified and changed.

Finally, I will close this post with a discussion about 3 rules of thumb suggested in the article that can help a developer to determine when to use the open closed principle. The first is to add extension points to classes that implement requirements that are intrinsically unstable due to instability of the system. This helps to clean the code which makes it easier for modifications of system behavior. The second is to not add more preliminary extension points. Finally, the third is to refactor parts of the code and to introduce additional extension points when the parts are unstable.

Overall I chose this article in order to compare my understanding of the OCP with another software developer. In my opinion, the OCP is based on indenpendence of methods, functions and classes. Although the article indirectly refers to this point, still I think it misses to introduce this point directly.

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