Author Archives: mesitecsblog

My First Sprint: A Retrospective

Good day my fellow readers. Today I will be writing a retrospective on my first Sprint. For this Sprint, we were tasked with mainly setup tasks from our Product Manager. The first task we as a group decided to conquer was the simple task of reviewing the README for the AMPATH software we would be editing. It appears that, from the last time our Product Manager worked with AMPATH, there was a contributing section that was removed in the current iteration. The next task tackled was to create a Github organization, fork the ng2-amrs software to the organization, and clone the software our machines. We then needed to ensure that npm, Insomnia, and a Typescript compatible IDE were all installed on our machines. I believe that we will need to install Gradle as well for some of the testing packages but, due to the pains that come with installing Gradle, as a group we decided that we can put off installing Gradle until it is determined that Gradle is actually needed. With all that situated, we then installed and played around in OpenMRS, a demo of an EMR, or electronic medical record system. The point of this was to gain a feel for an EMR first hand and it was neat to play around with one. The next task was to actually get ng2-amrs running on our units. This was the troublesome part of this sprint. During this part of the Sprint, I got sick and regrettably, did little towards getting it running on my unit at first. During that time, however, others in both my group and the other AMPATH groups did solve many of the issues that would crop up. This created a wealth of troubleshooting resources and made it much easier for everyone to get their ng2-amrs software working. At the end of the Sprint, our group did have a couple tasks left that we did not accomplish and had to push to our next Sprint. These tasks were to install both Karma and Protractor and learn more about both of them. They are both testing software that we will eventually be used for testing our changes to the AMPATH ng2-amrs software. We also pushed having everyone up and running with ng2-amrs due to some members, including myself still having issues getting it running. Thankfully, two members of our group have the software fully up and running.

This Sprint has forced me to dive back into some work from a previous class to remember how to work with npm and Insomnia. While I did not need Insomnia, in particular, this sprint, it was collateral learning. I also got a chance to learn about electronic medicals records as well and get a, “peek behind the curtain” as it were. We not only had to mess around with the OpenMRS software, but we also had to listen to an article called, “Why Doctors hate Their Computers”. This article, in summary, told the story of doctors struggling with their new EMR software and investigating the cause of this hatred. In the end, I came to the conclusion that the cause of the pain of doctors was that the EMR software was directed to the patient as the customer, rather than the doctors who actually use the software. This did put a thought into my mind that while working on the AMPATH software I should not only keep the doctors in mind but keep the patients in mind as well.

That is what happened, and what I learned on my first of many sprints to come. See you next time readers!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

Doctors Don’t Like Their Computer’s Huh?

Good day again my fellow readers! Today, I have read (well more like listened but I digress) an article titled, “Why Doctors Hate Their Computers”, from the New Yorker. It tells the findings of a Massachusetts doctor and his experiences when his employing hospital sends him to, “16 hours of mandatory computer training,” to learn the new electronic medical record system, EPIC. This experience then kicks off a search for the reason why these systems make doctors hate them, and the effects it has on those doctors.

The hospital was switching from proprietary software to the EPIC software and as the author has used the system, it has worn him out. To make a long article short, EPIC had added many more steps, clicks, and time to processes that had in the past, gone much quicker. The author mentioned that in the first month of the EPIC rollout in the hospital the IT Helpdesk logged 27,000 tickets. Working in an IT department currently, I may have done a spit-take when I heard this. The author also mentioned that because of these new systems, for every hour of patient interaction there are two hours of paperwork that has to be entered in the system. There was also a Mayo Clinic study that discovered a link between the burnout of doctors and the amount of screentime that they are subjected to. Bad software is literally driving doctors out of their career. This really surprised me. All of us have come up against some bad software design before, but I would never guess that bad software would cause someone to quit their career. As the article went on, the writer revealed that the software creators of EPIC tailor the software to the hospital utilizing it. For his hospital, meetings were held where both doctors and administrators were invited. I immediately thought that the culprit here was the administrators. The folks higher up, or in a different department got their hands in the part and got their interests, prioritized over the doctor’s ones. Then later in the article, he talked to the chief clinical officer at Partner’s Healthcare, who turned the argument on its head. The software is not for the doctors or the administration. It’s for the patient as more patients look at their records and visit notes and want more understanding. This gave me pause as I myself take advantage of these features as a patient. Having access to all this information is very comforting. I had to mull this over for a bit but I came to the conclusion that the patient should be the main customer in this scenario. The whole point of a hospital is to serve the patient and with how care is extending beyond the hospital, the software is going to reflect this. For the Software Capstone, I will be working with AMPATH on their EMR for charity work in Africa. In that scenario, patient interaction will stay primarily in the hospital. In such a scenario I would say that the software should be directed towards the doctor. This reasoning is because the major usability that the patient will get out of it, is not an option for the patient due to their situation. We will definitely leave the option to shift the priority to the patient but, at the moment it appears that the doctors are the current priority in this situation.

This was definitely an interesting article and the next time I visit my doctor I do have an inclination to ask what EMR that they use and how they “like” it.

Until next time readers!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

Bringing Back the Apprenticeship

Good day again my fellow reader! Today, I have read a chapter and some excerpts from the book, Apprenticeship Patterns. This book focuses on changing the mindset of the reader in regard to learning the art of programming. The traditional mindset of learning programming is more of a being talked at model. A teacher will talk at the students, and the students will repeat what the teacher says through classwork, homework, quizzes, and tests. This method of teaching does not lend itself well to programming where problems can crop up out of nowhere, and curveballs are always just around the corner. Apprenticeship Patterns puts forward the idea that for software craftsmanship, the apprenticeship model is a more fitting model to create well trained software craftsmen.

The apprenticeship model that Apprenticeship Patterns champions, is the classic model from the medieval era of apprentices, journeymen, and masters. The apprentice begins learning and doing small tasks and over time, will graduate to bigger and larger tasks and responsibilities. An apprentice, when he is ready will graduate into a Journeyman. A journeyman studies directly under the master. In addition, a journeyman is tasked to travel from master to master, expanding their knowledge in the craft and learning multiple styles from multiple different masters. This rounds out the path of a journeyman and eventually, they will attain the rank of a full fledged master. They will then continue the tradition and take on apprentices and journeymen just as their masters before them.

This cycle of apprentice to journeyman to master is a cycle that worked well in the medieval times but in today’s world, this model no longer fits anymore. I do agree with the statement that the apprentice’s apprenticeship was the sole responsibility of the apprentice alone and their success ultimately depended on them. This holds true today for the modern student but to a lesser extent as a student does not learn in the same method as the traditional apprentice. For the traditional apprenticeship to be revived in today’s modern times, there would be a drastic change in today’s society and in how the educational institutions operate. I am not sure how a modern apprenticeship for software craftsmanship would look like, but I believe that it would definitely produce a high level of software craftsmen.

The other chapter introductions discussed patterns that a software apprentice would go through in their educational journey. The first few patterns form a solid base for the apprentice to learn and grow in their journey. The next couple chapters have patterns that continue to grow the apprentice and nurture them into the position of a journeyman. These patterns take the journeyman outside of their comfort zone and allow them to grow through agitation of what they are comfortable with. The final patterns take the journeyman into a master by having one constantly learn and creating a feedback loop to keep one learning. These patterns look very interesting and I do hope that I will be able to apply some of them to my learning journey as well.

Let us see where these patterns lead us and see you next time!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

I’m Back. It’s Time For A Scrum!

Good day my group of probably 1-2 readers, I’m back! This time this blog will be dedicated to posts for CS-448, the Software Development Capstone at WSU.

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

Uh Oh! Spaghetti Code!

Hello, once again my fellow readers! I am sorry to report that this will be my last blog post for this semester and in turn this class. Continuing with my trend of Antipatterns today I will talk about a delicious Antipattern, Spaghetti Code.

SPaghetti code is the Antipattern that everyone first falls into when learning how to code a new language, learning a new coding tool, or learning how to code in general. Spaghetti code is the Antipattern representing code that has very little software structure. As a result, this leaves the code with a lack of clarity or direction, even to the original developer. This is the classic moment where you uncover code from some time ago, sit down, look at it, and go, “What was I even trying to do here?”

It can be quite easy to identify Spaghetti Code. Simply look for methods being very process oriented. Object implementation will also dictate flox execution. You will see minimal relationships between objects. You will see a very predictable pattern of object use.

Spaghetti Code can result in many consequences. Spaghetti code results in a program with diminishing returns. If Spaghetti code is mined, only part of the code will even be suitable for reusable if any of the code is reusable at all. As well, maintaining the code will result in being much more wasteful and a diminishing return as well. It will be more practical and less wasteful if a new solution is developed. Spaghetti code is so detrimental, it can even remove the benefits of object-oriented design.

To fix Spaghetti Code, you can refactor your code. Refactoring code is a natural and excellent way to maintain your code and is a wonderful way to increase performance. Code refactoring first must achieve a sufficient structure. Then, performance critical code must be identified and then structure compromises must be implemented as to enhance performance. Of course, the best way to get rid of Spaghetti Code is to prevent it in the first place.

As I was reading this, I knew that this is something that I could apply this almost immediately. In my next semester, I will have to work in a team and build off of an existing program. This Antipattern will stay with me and I definitely will see how I can work refactoring into the process to ensure that no Spaghetti code will remain. I have a sneaking suspicion that refactoring will be an idea that if implemented, will be able to squash many different Antipatterns that show up or are already lurking.

Well folks, this going to be my last blog entry for this semester. Thanks for reading and learning along with me (or watching me read). Until next time, have a wonderful day!


From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

I Know Halloween Was A Couple Months Ago But…

Hello, again my friendly neighboorhood readers!

This week I have been again been reading up on those crazy Antipatterns I discovered week. As you can probably tell by the title, the Antipattern I am writing about this week is a Halloween themed Antipattern. I know it’s a little late but today’s Antipattern is the Poltergeist.

A Poltergeist is a class that has a limited role to play or limited responsibilities in a system. This practice adds unnecessary abstraction and their short life cycle means more wasted resources. Poltergeists normally appear to initiate some other action of a class that has a more permanent status. A Poltergeist is easily identifiable as they will typically bear the “_manager” or “_controller” title in their name. The main three disastrous effects of the Poltergeist Antipattern is a waste of resources every time they are called, they utilize redundant navigation paths, and the clutter the object model, getting in the way of proper object-oriented design. If a Poltergeist Antipattern is left alone it can result in such occurrences as transient associations, stateless classes, redundant navigation paths, short duration, temporary classes, and objects, and single operation classes. Some typical causes that lead to a Poltergeist Antipattern manifesting are a lack of object-oriented architecture, using the incorrect tool for the job, and of course, a specific disaster such as management incompetence.

Now how do we fix this Poltergeist problem? Well, they gotta go. Of course, once the Poltergeists are gone, the functionality they had must be replaced with an adjustment to the architecture. Another solution is to utilize the 80% solution that we discussed in the post discussing the Blob Antipattern.

Now, I do not know about you reader, but I believe that this is definitely an Antipattern that every programmer falls prey too, especially when they are beginning. I can think of many programs that I have many over the years that have had at least one Poltergeist stalking around in them. This does make me rethink how I will program in the future. While the programs I may write now do not need any real optimization, in the future, optimization is going to be a required skill for me.

Well, that is it for today readers. Have a good week until next time!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

Common Software Testing Techniques

Good day, again dear reader! With classes wrapping up this week and finals starting, I was a little curious at what other testing techniques there were for testing that were not discussed in class. Of course, this lead me to an article called, “The 7 Common Types of Software Testing“. This article had a mix of things discussed in class and some new ones as well.

The first type of test was a black box test, something we discussed in class. In fact, it was among the first we discussed. For a brief review, black box testing is when we are solely concerned with inputs and outputs and we don’t know anything about how the code works or calculates the actual results.

The second test mentioned is white box testing. Another testing method discussed in class. If I remember correctly, it was discussed on the same day as black box testing. Here in white box testing, we can see inside and get a feel for how the program actually works and calculates outputs.

Acceptance testing is a new one to me. Acceptance testing is two-fold. It tests both the system as a whole and it tests the actual requirements of the customer. This test is geared more towards user-friendliness and usability that some of the other tests.

Automated testing is simply any test that has been automated. This I think is more part of other test techniques and not its own technique.

Regression testing is testing the system to ensure that it works the same way as the previous system. This is done in incremental development to ensure that as new parts are added, the original system isn’t broke.

Functional testing is the testing of the system to see if it is functional. The author points out that there is more than just functionality to test for a program and uses that to justify functional testing as its own technique. I’m not quite sure about this decision but I can stomach it for now.

Exploratory testing is testing a system without any actual test cases and exploring the system looking for things that might be wrong or unexpected. Reading the description, it appears to be for testing systems in unusual ways that might not be conventional and testing the boundaries of a system, possibly uncovering bugs that normal testing methods might not find.

Of these new test methods, none of them have really captivated me. Exploratory testing, being honest, sounds a little silly and I can’t really see too many benefits to it. Out of all seven I quite like acceptance testing as it seems to keep the focus shifted to the customer and not just to it the system works or not.

Until next time readers!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

I’m Sorry, an Anti what now?

Good day once again my fellow readers! In my readings this week, I discovered something that I had never heard of before, antipatterns. Now that is quite a striking name and it piqued my interest in this subject. So today I will be talking about software development antipatterns, particularly the Blob.

First, let’s discuss what an antipattern even is. An antipattern is simply just an industry term for a common solution to a problem that generates negative consequences. what antipatterns can do for us is twofold. First, they provide a template to help us recognize common problems that can crop up in software development. With this knowledge, we can recognize an antipattern when we see one and identify the cause of it as well. The second part is that antipatterns provide a constructive solution to fix the underlying cause of the antipattern and to implement solutions that can be applied at several different layers in design. Let’s look at the first antipattern I discovered, the Blob.

The Blob is much like its namesake of horror film fame, the Blob. Here one single complex controller class is surrounded by many smaller data classes that merely encapsulate data. In this architecture process is separated from data, thus making this procedural style architecture. Some typical causes of the Blob are lack of object-oriented architecture or lack of any architecture whatsoever. A common occurrence of the Blob is from iterative development where code evolves from proof of concept to a prototype to a functional system. Another cause is a lack of architecture enforcement. But how can we fix this Blob problem?

Refactoring to the rescue! The first step is to locate sets of operations and attributes that directly relate to each other under a common goal. The next step is to locate natural homes from these groups and migrate them to their new homes. We then remove all redundant, indirect associations and migrate associates to derived classes to a common base class. Lastly, remove all transient associations, replacing them if appropriate with type specifiers to attributes and operations arguments.

This discovery of antipatterns for me was quite the find. I don’t know what but I still get a strange feeling when I hear antipatterns. It just sounds so menacing. The Blob was an interesting first antipattern to read as I’m positive that over my past coding projects, many of them would probably fall into this antipattern. It is nice to be aware of these potential issues now, rather than further down my career where it could have a greater impact if I ever do fall into the trap of an antipattern. I definitely plan to read more about these antipatterns and I plan to write about another one next week.

Until next time readers!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

The Customer Wants What The Customer Wants

Hello, again my dear readers!

It appears that this week I am very focused on the customer this week as this article I read particularly focuses on what the customer wants. The article is titled, “Figuring Out What They Expected“. When it references they, the article is referencing the customer. The person you are programming the program or application for. Anyway, let us get into the meat of this article.

The article starts out defining two things. The first is what the user model is. The user model is effectively, what the user is expecting and thinking when they use the program. It bundles everything they know about computers and all their preconceived notions about using them when they sit down and use your program. How do I use this program and what does it do for me, the user? This is the model you are aiming to nail. If no one uses a program, does the program really exist? The answer is yes but we aren’t here to talk about that. The next model is the program model. This is what the programmer programmed into the program on how it looks, works, and operates. The idea in establishing this is that the user model and program model want to be overlapping or ideally mirroring each other. Now there are two ways to do this. The first is to change the user model. Good luck with that one. People are stubborn, stuck in their ways, and how would you even accomplish that anyway? Write a manual on how to use your program? We all know no one reads manuals anymore (although to be honest people really should) and if your program is different from what the user is used to, the user is likely to just not use your program. There is almost always another way. This leaves the program model changing to match the user model. I mean, let us face it, it might suck but you can change your program to match what the user will expect. It may be a pain but if it means your program is used more and ultimately bought more, I think it is worth biting the bullet.

The next part of the article goes over how to actually find that user model. The article has a simple and elegant solution… ask them. Then after you implement them, grab a few people and ask them to test them. Not a large group of people now. Only about 5 or 6 is required; after that, any more tests are fairly repetitive and not that useful. In the end, if the user has to guess how the program works, the program model is not quite there yet.

This article has reinforced my view that in this industry, the end user or customer is the ultimate determinant for a program or application. After all, we are programming an application for someone to use. If they can’t use it, its no good to them. I will admit, I’m surprised that only 5 or 6 people for usability testing are the norm. I do have a new appreciation for the Apple way of thinking where the simplest way to do something, is the way to do it.

Until next week readers!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.

Sure You Can Test, But Can You Really Test?

Good day my fellow readers!

As I have been learning all about software testing in class, the career of software tester has looked more and more like a job I would like to do. In my readings, I can across a blog post titled, “10 Qualities That Can Make You A  Good Tester.” I know hat you are thinking, “Ugh! Clickbait list articles.” but this one seemed relevant so I decided to have a read anyway.

The post starts off asking the question, ” What makes you think you are good at testing? Why do you qualify as a tester?” The author was saying that anyone with enough knowledge can test a program. It falls to different qualities of the tester that truly make them a good tester.

The first quality is that the tester understands priorities. What should be tested, what should be automated, what requires manual testing, what should be done first, ect. You are given a thing(s) to test and you have a limited amount of time to test them. Prioritization is a must.

Next, the tester should ask questions. The questions go farther than just, “What is my goal?” They must deeper like what changed, what was fixed, what is the product used for, or who will use it. The more understanding a tester has, the better they can do their testing.

The tester must be able to create a number of ideas. There isn’t just one way to test one thing and one product may be used in different ways. Simply put, more ideas = better testing.

The tester must be able to analyze data. Not knowing what data you get back means you are missing a big part of your testing as much of automated testing is reading and understanding data.

The tester must be able to report negative things in a positive light and be good at reporting. These are technically two points but they are practically the same thing. Reporting something in a positive way, even if negative, is a great way to build solid communication and improve teamwork. This plays into good reporting. People want to hear straight and to the point reports that get the point across and all the important parts. No one wants to sit there and read a list of negatives for minutes on end.

A tester must be able to support the developer. This goes beyond just finding a bug for example. A developer can’t fix a bug if they are having a hard time even recreating it.

The tester can co-relate real-time scenarios to testing. This sounds like a lot but it really boils down to A.B.T. Always Be Testing. Almost like improve testing. If you constantly test thing in your life outside the office, it can give you ideas to test things inside the office.

A tester must be a constant learner. Like the rest of the programming industry, nothing stands still and you shouldn’t either. Learn new technology, new tools, and new ideas.

The last trait is the tester must be able to wear the end user’s shoes. The ultimate goal of the product is to send it to the end user. If the tester can’t understand the end user, the end user will most likely not be happy with what they get.

One big thing stands out to me after reading this list… the end user is everything. In just about every article I have read the end user will without a doubt make an appearance in one way or another. If I can’t get my head around what the end user wants, I will not last long as a tester. The co-relate real -time scenarios was an interesting one as I like most, probably leave work at the office and never take it home. This takes work and home and fuses them keeping the skill of idea generation at the forefront. What surprised me a bit was that the reporting skills were geared toward streamlined and quick reports. I had expected reports in the testing world to be longer and more technical. This may just be the writer’s individual experience but it does make sense to me. The people testers report to literally made the thing they tested. They probably don’t need a nitty-gritty teardown.

Now I have some things to work on as a programmer before I graduate. They don’t seem hard thankfully, just something that requires a lot of time.

Until next time readers, have a good day!

From the blog CS@Worcester – Computer Science Discovery at WSU by mesitecsblog and used with permission of the author. All other rights reserved by the author.