Category Archives: Software Development

Indiv. Apprenticeship Pattern: “Expose Your Ignorance”

Between sprint tasks, I continued reading Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman by Dave Hoover and Adewale Oshineye for Software Capstone course this week, focusing on the “Expose Your Ignorance” strategy. In professional environments, software developers are often expected to have a deep understanding of the various tools and technologies they work with, but it’s common to encounter unfamiliar domains/situations.

This strategy approaches these situations by being transparent with employers/teammates about their learning process rather than pretending to already know unfamiliar content – even if the individual is able to self-teach the content to be able to follow through. In reality, they will need to learn the new technologies/skills regardless, and transparency on this allows employers and peers to also see your learning skills and personal growth over the course of a project. 

In doing so, software developers are approaching their situation from an honest angle which is far better for building professional relationships and management expectation. In a manager role, I would much rather hear 

‘well, this API is new to me but I’m making headway in learning and implementing it. I hit an obstacle, which may delay me.’

Over an employee claiming they are an expert and then failing to deliver on time.

As a part of this, the text also differentiates between an “expert” and a “craftsman”.  While experts focus on mastering specific platforms or domains, craftsmen are driven to continually learn and adapt by broadening their knowledge base. Naturally, the craftsman can’t become a master in every topic, but master craftsmen have developed in-depth knowledge of a few separate areas of technology throughout their career and ‘apprenticeship’. So, while they may not be the absolute expert on any given topic, they will have the skills to learn, adapt and overcome challenges involving almost anything.

I appreciated this differentiation and definition of what it means to be a craftsman. Earlier this week, I had a conversation with Professor Meunier in CS497 where he described similar concepts as they relate to graduates and job applicants. As an interviewer, he/others understand that graduates will not have deep knowledge in several areas yet but looks for a wide breadth of concepts/tools we’re at least familiar with and at least one area in which we have a deep knowledge. This could be visualized as a “T” shape – wide topped with one deep portion, but master craftsmen develop a knowledge structure more like an “M”, with a wide breadth of topics and a few with deep knowledge.

Sources: Hoover, Dave, and Adewale Oshineye. “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman.” O’Reilly Media, 2009.

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

Understanding Test Driven Development in Software Engineering

Test Driven Development is a method in software development in which tests are created before the actual code. By writing test before hand, developers have a clear understanding of what will need to implemented, which can help avoid unnecessary errors. This approach will help to have the software behave as expected. This method is a structured and systematic approach. This test method is doesn’t just focus on testing, however it also focuses on quality and behavior. The main goal of this test method is to ensure that the code meets the specified requirements and behaves as expected. Test Driven Development helps with clarifying requirements, reducing defects, and improving the code maintainability.

How does it work?

Test Driven Development operates on a cycle like, first write a test, second make it run, third change the code to make it pass, and then repeat. Developers should first write a test that will analyze the behavior that they want implement. After running the test and writing and rewriting the code to make the test pass, developers will then need to continue reframing the code to improve it’s design and maintainability without changing it’s behavior. This process will make sure that that each piece of code is throughly tested and validate before moving on to the next.

Test Driven Development vs Traditional Testing

The difference between Test Drive Development and Traditional testing is that test driven development method has a different approach and objective. Traditional testing methods usually aim to find bugs or even defects in code, test driven development mainly focuses on making sure that the code meets the specific requirements. A failed test in test driven development method tells the developers to write new code to fulfill the requirement’s, and it also tends to make sure that the code will be lead to higher quality, with fewer defects.

There are also two levels of test driven development that focuses on different aspects of software development. Those two levels being Acceptance TDD and Developer TDD. Acceptance involves writing acceptance test that verify the overall behavior of the systems based on the users requirements. Development TDD, focuses on writing unit tests for individual components or modules of the system.

Why Did I pick this Article?

I chose this article because Test Driven Development is a very important concept in software engineering. This article has taught me a lot about test driven development , which include numerous benefits like improved quality of code, reduced bugs and fewer defects, and faster development cycle. These many advantages are valuable for any software development project.


After reading this article, i have learned a lot about Test Driven Development and it’s many advantages. One key take away for me was how in this method developers are to write test before actually writing the code, which can help in clarifying and ensuring that the code is correct and meets the required specifications. I also found how the article talks about the difference between test driven development and traditional testing methods. Learning about the Acceptance TDD framework helped me with my understanding of how test drive development can be scaled for larger projects and integrated into Acceptance methods.

Now that my understanding has been enlighten with this new found valuable knowledge and insights into test driven development methods, I can apply this in my future software development projects. I will also be able to writer better, cleaner, and more maintainable code when using this method.

Article link is Here:

From the blog CS@Worcester – In's and Out's of Software Testing by Jaylon Brodie and used with permission of the author. All other rights reserved by the author.

Indiv. Apprenticeship Pattern : The White Belt

In CS448, we’ve begun independently reading Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman by Dave Hoover and Adewale Oshineye and looking deeper into the patterns discussed in the first six chapters. The first Apprenticeship Pattern I focused on was the first described in Chapter 2 – the “White Belt”. This pattern suggests taking a beginner’s mindset with an emphasis on humility and open-mindedness when learning new things or otherwise addressing professional development. 

This pattern’s Context statement grabbed my attention because it felt very relatable as a senior with a strong understanding of Java who is looking at delving deeper into other languages like C++ and JavaScript. While I have a solid grasp on Java and general programming concepts, I have a lot to learn and really at a beginner level in other languages as I need to relearn basics like proper syntax as well as other concepts like memory management. To this point, one aspect of the White Belt pattern involves admitting ignorance – there’s much more than I don’t even know I don’t know yet. But, I also find this to be encouraging – I also don’t know how much I can possibly learn and gain professionally by taking this perspective in picking up skills.

Another concept that’s brought up and discussed with the White Belt pattern is the notion that particularly when learning and strengthening new skills, it is going to take more time to do tasks that would otherwise be simple to us in our first language – but that is okay and to be expected. This can be a point of frustration for me personally, so it was nice to see this acknowledged and helpful as I can address these tasks in a more patient headspace prepared for slower speed. Furthermore, the long-term benefit to struggling through this slow period usually pays off – the authors eloquently put it as “losing some productivity in the short term in order to take a leap forward once you master the new approach.”

Embracing humility, admitting ignorance, and actively seeking to understand challenges are key components of this pattern that I also try to live life by. So, the “White Belt” individual apprenticeship pattern was very insightful and impactful to read about and a great introductory pattern to more soon to come. It seems most applicable to situations where I/my team will be learning or enhancing skills, particularly when working with others and in environments with more experience to learn from. As a soon-to-be graduate, I look forward to keeping this pattern in mind as I enter the professional field.

Hoover, Dave, and Adewale Oshineye. “Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman.” O’Reilly Media, 2009.

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

Apprenticeship in Software Development

If you’re like me, you probably dislike doing reading for school and find it to be pretty tedious, usually resulting in a drab writing exercise afterwards. So, reading through the first chapter and then the introductions to the following chapters in our textbook Apprenticeship Patterns – Guidance for the Aspiring Software Craftsman seemed like it would be similarly boring/tedious, but I found the writing to be engaging and discuss relevant topics with relatable analogies. 

The first chapter was primarily an introduction, and I found its discussion of what Apprenticeship is and means in modern society versus how it was implemented in Medieval times where the term originates. One point brought up is that modern “apprenticeships”, or positions with a similar title are more similar to what I think of as an internship, and may involve a lot of training but it mostly involves learning how to use a system/software rather than learning how it actually works behind the scenes or even how to improve it. 

By the same token, the author’s discussion of Medieval apprenticeship and how it correlates to modern situations resonated with me – particularly the division into the three main classes of Apprentice, Journeyman, and Master. Looking back, at the beginning of my Computer Science degree I was certainly a green apprentice and came in with an open mind and I was very fortunate to have family members who are undoubtedly masters to help teach me as their apprentice. Thinking about these individuals, they ARE in fact always learning more and new things and in their own way delving into their own areas of interest to try things which may have never been done before. But, as I approach graduation I feel myself starting to have more tendencies and qualities of a Journeyman as described. With early-career C.S. trends commonly involving a few different companies or departments, it’s easy to see more correlation there to the Journeyman, who travels sharing knowledge with others while also learning from them and improving their repertoire.

In reading the introductions to chapters 2-6, I found them to be quick, engaging and informative – exactly my type of reading. The chapter 3 introduction about Taking the Long Road resonated with me the most and left me with a lot to think about. Many times I’ve found myself feeling like the individual in the example, both inspired/excited by the sheer power and intellect of some other around me and discouraged/terrified of how far ahead of me they clearly appear to be. However, as the text discusses we are all traveling on the same general road as developers and Computer Science professionals, some have just been traveling on it longer, faster, and/or in different directions than us. It’s largely about the journey that gets you to your destination, which we will inevitably achieve as long as we refuse to give up.

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

An Intro to TestProject as an Automated Testing Tool

Classes restarted last week, and during the first week I found myself reading and writing a lot of introductory blog posts about upcoming semester course topics. As part of my setup tasks for CS-443 Software QA and Testing, I read about one of the most popular manual API Testing tools Postman and saw reference to TestProject, an automated testing tool from the same company Tricentis. So, I decided to do some further reading into TestProject as I understood the basics of manual testing, but had not seen automated testing in action yet. To do so, I found a blog post on the Tricentis site containing an overview tutorial of API testing and how platforms like Postman and TestProject can be valuable.

The post begins by discussing the value in API Testing and mentions the utility of Postman, but also brings up some of the limitations that are commonly encountered such as test automation, scheduling, and end-to-end test reporting. Intro TestProject → This testing platform offers solutions for end-to-end API testing by providing an environment to not only test API’s, manually but also to automate API-based test flows, schedule and run them periodically, and generate execution reports without the need for third party tools or writing any code.

The blog also contains a six chapter tutorial on using TestProject, so I delved into Chapter 1 – Basic API Test Automation. This emphasizes the platform’s ability to handle a wide variety of input sources like HTML, Databases, and more, then showing the application GUI and taking the reader through how to add ‘test steps’ in TestProject to set up automated testing for a GET HTTP request using NASA’s public APIs including search parameters and discussion on Dynamic Endpoint URLs (and implementing them) amongst others. Chapter 2 offers another brief tutorial discussing the value of scheduling automated tests with image steps (guide) to doing so with interactions to Android and iOS systems.

From these introductory chapters, I was able to get a basic idea of how to use TestProject to design calls, execute tests and access result reports. The other chapters in this TestProject tutorial cover more advanced API testing and validation flows, shell commands, scheduling API automation and more. As an introduction to Quality Assurance Testing and the course in general, this chapter was intriguing and valuable to get an idea of what an automated software testing tool looks like and how to use it in a basic sense. Stay tuned to read more about these other chapters and other topics in software quality assurance and testing and other exciting computer science related topics!

General TP Post:

Chapter 1: 2:

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

An Intro to LibreFoodPantry and Thea’s Pantry

In reviewing the information about LibreFoodPantry at their website as preparation for work in the Software Development Capstone, one particular point that I found interesting and surprising – but enlightening was a portion of the Mission statement. Through its Free Open Source Software and other features, LFP aims to convey to our communities and the world as a whole that computing can be used for social good. I had not thought about the project from this perspective, but it is an interesting and exciting value proposition and completely valid – computing could likely be used in many other instances for social good.

In exploring the subsystems in the repository for Thea’s Pantry and specifically the Documentation section, I was most drawn to the Developer repository, containing documentation that will be most relevant to developers working on the project – such as myself and my teammates. All of these contain valuable information about various components of the system/subsystems like the overall architecture, guidelines for Conventional Commits, and more. Furthermore, I have been interested in picking up Documentation writing as a skill and get some experience with it, so this is an area where I may be able to do so and assist Dr. Wurst in filling out the Developer Documentation. I’m looking forward to getting hands-on experience and making progress in improving the Thea’s Pantry systems this semester!

LibreFoodPantry site:

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

CS443 – Introduction

Hello everyone, we are back and doing it again this semester. Tech Worth Talking About returns with posts about two courses, CS443 – Software Quality Assurance and Testing as well as CS448 – Software Development Capstone.
CS443 will focus more on strategies and tools for automating code testing as well as how testing incorporates into the overall development process. This goes far beyond simply debugging.

Welcome, and stay tuned!

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

Week 14 – Token #2 – CS-343

For this blog, I specifically wanted to look into how this class relates to the preferred field I want to go into, which is Game Design. I wanted to see what kind of languages would be used, what kind of design elements are implemented, and even in the case of frontend vs. backend, how online games employ servers.

However, it seems like I had a misunderstanding that these two positions were similar omewere, as I find many sources that say software design vs. game design are a completely different beast, which only made me more interested. I did some more research, and this lead me to end up reading this article below:

Specifically I noticed that software development has more rigidity when it comes to designing and delivering a product. Software engineers are usually employed to design a software to meet consumers demands, which usually entails specific features and options they’d want in the software you’re developing. Whereas with game design, you have a much more flexible development cycle, as theres a lot more creativity involved. You’re less focused on making sure specific features are available and more focused on delivering a product that is unique and interesting for consumers, and keeps them engaged.

Game developers also rarely work with programming languages when it comes to development of products. Game developers mainly use engines, which are interfaces that employ programming languages to create building blocks to build off of to create a video game. Software engineers mainly work with the code directly at almost all times, making sre each line is properly written. That’s not to say some game devs don’t work with code directly, some do, and many Triple A companies actually write their own engines using their own code, like in the case of Epic Games’ Unreal Engine, which is used to power their famous game Fortnite.

Something this article notes is that software developers may not need to worry about performance compared to game developers, and I can understand why they might say that. Games rel on having a fluid and enjoyable experience, and that is dependant on the performance of a game, making sure theres no glitches, bugs, or lag. However, I would argue that performance is still a factor within software design too, because what if a simple calculation process in a program takes multiple minutes? Consumers will still have an issue with that. While I do think it’s definitely a lot more important in game development, that’s not to say it’s not unimportant in software design.

And that’s all my blogs for this semester! I’ll be taking another of Professor Wursts classes next semester, so I’ll likely be writing again then. See all you readers come January!

From the blog CS@Worcester – You're Telling Me A Shrimp Wrote This Code?! by tempurashrimple and used with permission of the author. All other rights reserved by the author.

AHK as a Developer Tool

AutoHotKey Scripting Software

AutoHotkey (AHK) is a powerful and versatile free, open source software and scripting language for Windows operating systems exclusively. It provides an environment where users can create custom scripts to automate repetitive and/or menial tasks, create custom GUI’s, manipulate windows, files and applications, and create custom hotkeys, macros, and key-rebinds. Users can quickly create and tailor scripts toward specific tasks they face to significantly improve their overall efficiency and minimize errors. In essence, AHK can be used to automate and otherwise enhance users’ ability to perform software development and other processes from start to finish.

Upon downloading AHK, the main Dashboard GUI has several useful features to help users get started and in general as they create scripts, including a compiler, link to Help Files, Settings, and a Window Spy tool to extract application window data. Using Window Spy, users can easily identify and access a window’s “ahk id” to hook into and directly input to that window using AHK methods, such as ControlClick, which sends mouse inputs to a given client at a specified x-y mouse coordinate. Conveniently, the Window Spy tool also provides functionality to easily identify the on-screen/client x-y coordinates of a given mouse position. There are similar functions for directly inputting strings (rather than clicks).

One of the most intriguing features of AHK which led me to pursue learning it on a deeper level is its capacity to directly interact with application client windows and any separate application GUI’s (including mouse and key inputs, minimizing/maximizing, setting window focus, and more) without focusing on them and interrupting other active processes. This is extremely beneficial for testing, data collection/recording and more – for example testing may be run in the background with the results recorded to an output file whilst the user is actively working on other tasks independently. Furthermore, AHK scripts can easily be set to repeat at a specified time period; the previously mentioned background testing/recording can be called upon to execute every X minutes with zero input from the user or interference on their tasks. Increased convenience and efficiency with less human error or interaction!

Some other functions in AHK which I have read or seen videos about and hope to start implementing soon include PixelSearch and ImageSearch. PixelSearch is a versatile tool of the form: 

PixelSearch, &OutputVarX, &OutputVarY, X1, Y1, X2, Y2, ColorID , Variation

Searching for a specified hexadecimal ColorID within the specified screen space and returning output variables containing the coordinates of the first found pixel of that color. The outputs can easily then be used in other functions, and this method synergizes well with other tools that may identify certain occurrences with a color highlight or other marker. The ImageSearch function works similarly, but takes an Image input (easily generated with the Window Spy tool) and searches for an occurrence of the input within the search coordinate range. An interesting component of both PixelSearch and ImageSearch is the Variation parameter visible above near the end of the PixelSearch skeleton. This variable allows variance in the color/image which is being searched for to increase the likelihood of finding the target even if minor screen/image shifts have occurred, which can be common depending on the application or instance.

There are countless other features and functions in AHK which I have not yet gotten a chance to learn about. If you or a friend/colleague have experience with AHK functions, feel free to reach out with questions/discussion/advice to my email at !

Information/Source Links:

Post discussing use of AHK for coding:
AHK Home site:
AHK Method Documentation –

From the blog CS@Worcester – Tech. Worth Talking About by jelbirt and used with permission of the author. All other rights reserved by the author.

WSU x AMPATH || Sprint Retrospective 6

Sams ShipsHey guys, it’s a weird feeling to be wrapping up my last semester in my undergraduate career in computer science (and sociology). For this final installment of my AMPATH sprint series, I will just go over the general overview of what went on for my team.

Most of our updates went onto our PowerPoint presentation, which is going to be presented on May 15th, 2019. My team and I are looking forward to presenting the overall process of our group’s learning and working process, the many lessons we learned, our advice for future students, the work we tried to implement, and various other technical aspects of our project.

We decided that on top of the search bar work, it is also a priority to organize the git repository so it can be better organized and an open work environment for other classes. I think this is important especially when new people come in and cannot efficiently locate and access the files they need. As someone who was once new to an organization that had a lot of different projects and files to sort through, I believe that this is very considerate of the team to go with this.

With some limitations my team had to face, we worked around it to determine how we should move forward. The end result is pretty much a search bar that is attached to the toolbar. It cannot currently be live tested due to there being no backend but it can definitely be done in the future under certain circumstances.

It was interesting being able to observe how much planning you can start with but still end up having to take detours, starting new paths completely, or sometimes even needing to take U-turns.

I thought it would be important to pull some of the advice for future students from our PowerPoint and include them in this wrap-up:

  • Point out and address problems with technology right away because others around you might have the same problem(s) so you can solve them collectively
  • Do all team implementations in a separate component based on what you will be working on
  • Merge your work constantly to the master branch so each team can have the updated changes

A pattern I am noticing in a lot of teams or group projects is that not everything is going to work out in ways that you expected or were hoping for but you learn to move as a shifting team to make progress and continue growth.

Overall, I’d say I learned an important life lesson from this: if I am to contribute extra time on top of my technology career in the future to work on side projects, it will be a challenge to allocate time if it is a group initiative. I also learned that even when we try to communicate everything there is still more room for miscommunication, so there may be no such thing as over-communicating. I am happy to say that we always tried our best to move forward in all ways!


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