Author Archives: Stephen Burke

Pattern 3 – The Long Road

I thought the title of The Long Road would make for an interesting pattern to read, so I chose it for this particular post. This pattern describes the path that a craftsman will have to take to become a master throughout their career. This is specific to becoming a master of software development and not particularly for what is traditional success in a career path that we as newly graduating software engineers are “expected” to follow.

For this reason, I honestly disagree with the general idea of this pattern completely. The pattern does make it clear that this is the path specifically for people whose life goal is to become the best at software development and does not seek anything else out of a career in software development. I don’t see this as the norm, or generally good advice in any regard. I also feel that it is important to state that this is merely my opinion, but also one that I strongly believe in. From everything that I read about software developers who stick strictly to software development throughout their careers, they often burn out but also feel that it is too late in their careers to do anything else. These are engineers in their late 40’s and 50’s who have been working for the same company for well over a decade and feel that their knowledge in software development is so narrow because of a lack of exposure to other tech and other business domains. While this is not always the case, this is just what I’ve read and have been exposed to personally.

The pattern also preaches how admiral it is to stick to this strictly developer mindset and how money and promotions should not be a focus for you. While I think that this is important to not be the only focus in a career, this is just silly. Promotions and salary should not be a measure of your success but they should be something we all seek, and a goal for people to strive for throughout their careers. The way this pattern is worded, it seems to try to even nudge readers away from positions like architects where you aren’t specifically writing code on a day to day basis. It wants readers to avoid big picture positions and exclusively stick to coding. There is always more to learn in coding and we should all do something we love, but coding should not be the only aspiration for our careers. For that reason, this article has not changed how I will approach my career, but possibly reinforced the goals I previously had.

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Pattern 1: Your First Language

I decided to dive in with one of the first patterns of the selection, “Your First Language”. I chose this one because I was curious about the tips that the author would give individuals trying to decide on a first language, as well as to see if any of the tips translated for someone like myself, who is trying to branch out into learning more and more languages. This pattern breaks down the steps to choosing a first language and gives several factors for why you should potentially choose a language but makes sure that it is clear that these are tips and not the only reasons for selecting a first language. After picking the first language, the pattern lays out some tips for how to actually learn the new language. The pattern also lays out a simple means of learning more languages down the line and why someone should pick a particular different language.

I’m glad that I chose this pattern because I’m currently in a position where I am forced to learn a new language for a job I will be starting after graduation. The language that my new position almost entirely uses is C++ and I have absolutely no experience in it. The procrastination is killing me as my “native tongue” as the pattern describes it, is Java. Java is what I always try to use to solve problems even if I’m being asked to write in a language like javascript, python, etc. I always revert back to the concepts I’ve learned throughout college almost exclusively using Java. Learning C++ is going to be something that I must do and will attack throughout the next few months before starting my job. The opening to the article was also very helpful in relieving the stress slightly as it talks about how when you start your first job, you’re not expected to be an expert in ANYTHING. I’ve learned that through my last two internships where even though they were both Java based, they used entirely different frameworks and almost everything that isn’t core Java syntax, required an entirely different skill set and understanding.

The only part of the pattern that you could argue I disagree with, is the complete focus on your choice being driven by potential physical mentors. With the internet and communities within the internet, it is relatively easy to find mentors online who are more than happy to answer any of your questions in understanding a new concept or a language for that matter. Overall, I found this pattern VERY useful!

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Re: “Why Doctors Hate Their Computers”

After reading the article on “Why Doctors Hate Their Computers” I found the use of scribes for doctors to be rather interesting. The patients and doctors were both missing out on valuable face to face time because of the tediousness of the software and the constraints of the system. I was shocked to find out that the scribes were making minimum wage in most cases as well as the turnover rate to be as ridiculous as most of them only lasted mere months. I feel that if the pay was increased, the position would be drastically beneficial for both parties involved. The doctors would be relieved of their note-taking duties for the most part, while the scribes, who were often med-school students, or those seeking medical schooling, got some hands on experience in a doctor’s office. This goes without saying that the additional patients per doctor that was happening to the example in the article, defeats the whole purpose. The whole struggle to finding a happy medium between functionality and feasibility for clients is not limited to the world of medical software but a struggle that exists in almost every avenue of software, even the consumer market.

One of the biggest tensions for the doctors is the concept of getting to the next patient as quickly as possible, while maintaining a personal relationship with patients, all at the same time maintaining the monotonous documentation system that the software has become. The doctors have taken on additional tasks without additional personnel being hired to lighten the overall man-hours required to perform all of the tasks for individual patients. The scribes help with the doctor’s desire for more face to face time with their patients but again, defeat the original purpose of the software, to be more efficient than a paper system. Those without scribes were often taking on hours of work to do at home as they simply did not have time to complete their note-taking during regular office hours. While the system was meant to make lives easier for doctors, it often wasn’t.

Despite the results, the customer for the system is still the doctors. They’re the ones who are directly using the software as well as giving input to the developers for changes. Some may argue that it is the patients as the whole service of medical care is for them, but like Quickbooks is for accountants, Epic is for doctors.

The lessons from the implementation of this system apply to almost every industry. The man at the end of the article is a perfect example of this, as he was experiencing similar problems at his job as a construction supervisor. Many individuals are losing their direct interaction time aspects of their jobs to devote the time to using software in one way or another.

I’ve always thought of this battle between ease of use and complete functionality as a struggle that directly works in the world of security. People are always afraid of being hacked, or their information stolen but if the system is complicated, and has extra steps for users to ensure security, users want an easy way out. Whether it be simple passwords, or a lack of use of two-factor authentication, users often want the easiest means of use over the most secure means.
Link to the article here:

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Apprentice Patterns: Ch1 + 2-6 Overview

After reading the first chapter of Apprentice Patterns, as well as the introductions to chapters 2-6, I have a lot of comments. The first chapter does a great job of setting up the reader with the understanding that this book is for the “little guy” on the ladder of software development. The different pieces that give definitions and explanations for the different roles of apprentice, journeyman, and master, give readers a means to compare the roles in the specific context of software development.

I do have to note that I disagree with some of the points that the first chapter makes. The first chapter talks about the horror stories of first jobs, or early career positions in general for the software developer. I feel that these claims are simply outdated. Because there are so many positions that need to be filled for mid-level developers, companies are doing all that they can to fight for early career, or fresh-out-of-college employees. There are incentives like a guaranteed mentor and open-concept work environments where collaboration is not only encouraged, by a key part of what might be considered the mission statement of the software development department of the company. These open-concept environments lack traditional cubicles that the book refers to as “ small, rectangular stalls with a PC and a crippled Internet connection”. While many, and most likely most companies still have cubicles, the other points have all been existent in every company I interviewed with both for internships and for full time positions before making a decision. One of the reasons why I decided to accept the offer I did was because of the guarantee that I will have a mentor for my first year of employment, as well as the open concept, extremely team focused work environment. While I do think it is important to note that some people might not be so fortunate, it is also just as important to recognize that there are companies that strive for the mentorship situations the book seems to think don’t exist.

One of the chapters that appeals to me the most is chapter 2. The story of the philosopher and the Zen master. I feel that many people feel that they need to learn everything in school and have an overwhelming fear that they don’t know everything that they need to know for their first job out of college. I felt this way before my first internship. After two internships, I’ve learned that you simply cannot be completely prepared for everything that a job is going to throw at you. The best you can do is try to master what you’ve learned and be open to new techniques, technologies, business logic, and entirely different work patterns. Like the journeymen described, who travel from master to master, learning the optimal means of their craft, we will work with different “masters” throughout our careers, and to be successful, we have to be able to identify the “best” techniques and it is our duty to share our knowledge.
Another chapter that I feel furthers many of these points is chapter 4. This chapter talks about the idea of not becoming comfortable with your knowledge and accepting it as your limits. The idea is not to measure yourself on comparing yourself to other developers in an attempt to become better than average. Instead we are always trying to become a better version of ourselves compared to the day before.

I’m overall excited to read through this book, and to relate myself to the patterns in the book. 

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

First CS-448-01 Spring 2019 Post

I’m back with another set of blog posts for CS-448.

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Mocking & Mockito

For the final blog entry for this class, I decided to cover a topic that I’ve had personal experience with but wanted to review for further review and understanding, mocking and specifically, mockito. I found an article on by Ivan Pavlov about mockito that is a guide for everyday use of the tool, exactly what I was looking for! The article has sections that includes some in depth analysis that could likely be used as a more in depth documentation for several aspects of mockito. The article also includes some insight into what mocks and spies are in the context of testing, unit testing specifically as well as some examples of the mockito tool in action.

For unit tests, we are testing the smallest unit of code possible for validity. The article states that the dependencies are not actually needed because we can create empty implementations of an interface for specific scenarios known as stubs. A stub is another kind of test double, along with mocks and spies, which are the two test doubles relevant to mockito. According to the article “mocking for unit testing is when you create an object that implements the behavior of areal subsystem in controlled ways.” They basically serve as a replacement for a dependency in a unit test. Mockito is used to create mocks, where you can tell mockito what you want to do when a method is called on a mocked object.

A spy for unit testing is another test double used by mockito. A spy, unlike a mock, requires a non-mocked instance to “spy on”. The spy “delegates all method calls to the real object and records what method was called and with what parameters”. It works as you would expect a spy to, it spies on the instance.  In general, mocks are more useful than the spy as they require no real implementation of the dependency as the spy does. The spy is also an indicator that a class is doing too much, “thus violating the single responsibility principle” of clean code.

Mocking with mockito can be used in a situation where you want to test that an object is being assigned a specific value when a method is called on it and certain parameters are met. A mock does not require the implementation of the methods to be written yet as you can assign values when a method is called by the power of mockito. This is why mockito is such a popular testing tool and mocking is such a popular testing strategy, and why I’ll continue to utilize it whenever relevant.

Link to original article:


From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Boundary Value Testing

For this week’s blog post, I wanted to cover a topic that we covered earlier this semester, boundary value testing. I found an article on seemingly my go to site for articles for this blog, guru99. The article has several sections including a brief definition on what boundary testing is, as well as a definition of what equivalent class partitioning is and the relationship between the two. There are also a couple of examples and an analysis section that explains why we should use equivalence and boundary testing.

The article describes boundary testing as “the process of testing between extreme ends of boundaries between partitions of the input values.” These extreme values include the lower and upper bounds, or the minimum and maximum acceptable values for a given variable. For boundary testing, you need more than just the minimum and maximum values though. For the actual testing, you need a value that is just above the minimum, a nominal value that lies somewhere in the middle of the range, and a value that is just below the maximum value.

Equivalent class partitioning is explained by the article as “a black box technique (code is not visible to tester) which can be applied to all levels of testing.” It also states that when using equivalent class partitioning, “you divide the set of test condition into a partition that can be considered the same”.  This may sound a bit confusing but it is actually pretty simple. The article uses an example of a ticket system where values 1-10 are the only acceptable values and values 11-99 are invalid. You could break up this set of numbers into two different equivalent class partitions and then returning back to our boundary testing concept, we would test values like 0, 1, 5, 9, and 10.

The best part about boundary testing is that because it is a form of black box testing, you do not need to see how the actual code works. You only need to know the specifications for the valid and invalid numbers. Another reason to use boundary testing is that it eliminates the need for testing every value and thus, minimizes the tests needed. I have and will continue to utilize this testing strategy throughout my software engineering career.

Link to original article:


From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Mutation Testing

For today’s blog post I wanted to cover mutation testing. I felt that this was a topic that we went over in class but felt like I may have missed something due to the short window of time that we had to review the topic. I found an article on guru99, a site that is becoming a go-to site for me, that is specifically about mutation testing. The article has several sections including a general overview of what mutation testing is, different types of mutation testing, and the advantages and disadvantages of mutation testing.

The article states that mutation testing “is a type of white box testing which is mainly used for unit testing.” White box testing implies that the code is inherently visible and known to the tester, or the person writing the mutation tests in this particular case.  The article states that the goal of mutation testing is to “assess the quality of the unit tests which should be robust enough to fail mutant code.” This opens up the conversation of what is this mutant code you speak of? The mutant code is a slight altercation to the original, and intended code such as changing a conditional > to a <. One of the most important aspects to note is that when performing mutation testing, only one altercation should exist for each test case. In the example I gave where you could change a > to a <, this would be the only change that would be made in the entire code that is being tested.

The article states that mutation testing is useful (the advantages) because “It is a powerful approach to attain high coverage of the source program,and it has the “capability to detect all the faults in the program.” Mutation testing finds any instances where a test should be failing but it is not. One of the biggest faults of mutation testing is that is nearly impossible to maintain without an automation tool, as stated in the article. The number of possible mutations to attain full coverage is not realistic to attain without automation.

I could see myself using mutation testing in the future as a means of attaining full coverage for testing. It is definitely a powerful means of testing if it can feasibly be implemented.


Link to original article:

From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Stress Testing and a Few Implementations

For this particular post, I was in the mood to cover something that we haven’t specifically covered in the class, stress testing. I found a post on that covers stress testing as a whole. The article covers aspects including the need for stress testing, as well as different types of implementations of stress testing. I particularly enjoyed this post because it covers a broad realm of topics within this particular area of testing, while being easily understandable for someone who may have no familiarity with the concept whatsoever.

Stress testing is often associated with websites, and mobile applications that may experience abnormal traffic surges during some predictable times and sometimes completely unpredictable times. Stress testing ensures that a system works properly under intense traffic, as well as displays possible warning messages to alert the appropriate people that the system is under stress. The post points out that the main end goal of stress testing is to ensure that the system recovers properly after failure.

A few different means of stress testing are, application stress testing, systemic stress testing, and exploratory stress testing. Application stress testing is pretty self explanatory, this test basically looks to find any bottlenecks in the application that may be vulnerable under stress. Systemic stress testing tests multiple systems on the same server to find bottlenecks of data blocking between applications. Exploratory stress testing tests for some possible edge cases that are probably unlikely to ever occur, but should still be tested for. The post gives examples of a large number of users logging in at the same time and when a particularly large amount of data is inserted into the database at once.

I knew that this kind of testing had to exist because of my experience with certain applications. Years ago, when a new Call of Duty game would come out, it was often unplayable for the first day or two, due to the network system being completely offline or simply unstable. Now, presumingly they have figured out their stress testing as the service does not go offline on release and hasn’t for several years. Personally, I don’t know if I will particularly be involved with stress testing in my career but the exposure to this area of testing cannot hurt. I do recommend that people take a look at this post on guru99.

Here is a link to the original post:


From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.

Testing & Agile

For this week’s blog post, I decided to find a blog post on a topic that we haven’t explicitly covered in class. I found an article on Agile Testing and my interest in Agile as a whole drew me in. This article is on QASymphony and breaks down what Agile methodology is, some examples of Agile testing, and how to align testing with the Agile delivery process. For the sake of this post, I will assume you’re familiar with the general concept of the Agile methodology for software development, hopefully you understand the general concept of Scrum and Kanban.

One of the interesting testing strategies for Agile development is the Behavior Driven Development tests (BDD). These tests are similar to the Test Driven Development (TDD) style testing systems in traditional waterfall development cycles. They are basically a replacement. Instead of writing unit tests before code is written, the BDD tests are on a much higher level. This is how user stories are written. The development of the code is based on end-user behavior and the tests need to be readable for those who might not be particularly technical as they can often replace requirement documentation. This saves time in the long run as there is no duplication of the process for those who might not be able to read user tests in the traditional TDD style of testing. The best part about BDD testing is that the tests do not necessarily need to be written by technical team members. These can, and are often written with input from business partners, scrum masters, and product owners who might not necessarily be able to contribute when it comes to writing unit tests in the TDD format. This style also allows for testing small snippets of functionality like TDD so that one aspect of TDD that is somewhat Agile remains intact for BDD testing.

After reading through the other testing strategies and how to align testing with the Agile methodology, I realized that I’ve already been working in systems that operate like this at my summer internships. We operated our testing in a format pretty much identical to the concept of BDD where everyone in the team contributed to the different testing obstacles and even came up with test cases that would need to pass by code that was written afterwards. And like the article says, it was common for not all of the tests to pass immediately, and this is part of the concept of “failing fast” that Agile is all about. I am glad I found this article to give me more insight to how businesses around the world, including the ones I interned at, are converting to Agile and utilizing these testing strategies if they haven’t already.

Link to original article:


From the blog CS@Worcester – The Road to Software Engineering by Stephen Burke and used with permission of the author. All other rights reserved by the author.