Category Archives: CS-343

Learning PlantUML

This week, I found myself grappling with the fundamentals of PlantUML, a versatile language that allows the user to quickly create code diagrams. My encounter with this tool was prompted by a task that required me to construct a diagram for a Java program. To help myself get ready for this project, I decided to delve into some reading on the subject, and that’s where I found this weeks blog.

“The .NET Tools Blog,” more specifically, their comprehensive entry on PlantUML diagrams, available at https://blog.jetbrains.com/dotnet/2020/10/06/create-uml-diagrams-using-plantuml/, was a great resource in my learning on plantUML. This blog post, tailored to beginners like myself, served as an excellent starting point for comprehending the intricacies of PlantUML and its best practices. While it isn’t an exhaustive guide, it offers valuable insights and practical code examples that helped me feel much more comfortable using this tool. This directly relates to the courses content as our current homework assignment revolves entirely around understanding plantUML. I will definitely keep this on hand to refer back to until I get more comfortable with the basic syntax of the language plantUML

I wholeheartedly recommend this resource to anyone embarking on their PlantUML journey. The provided class diagram examples not only facilitate a smooth onboarding process but also serve as a foundation for crafting more intricate and detailed diagrams. The blog post also delves into PlantUML “use cases,” a facet I had yet to explore. These use cases appear to be an effective means of illustrating the interactions between users and the software, potentially serving as a valuable tool for communicating a program’s functionality to clients or customers who may not be well-versed in deciphering traditional blueprint-style diagrams.

As for practical applications of this information, as I was saying before these diagrams can be helpful to expain the overall structure and function of code to someone who might not understand a more complex explination. This is not the only application however. You could also apply plantUML to help plan a complex program before starting your programming. Even experienced developers would benefit from a tool to help quickly make a diagram that would let them see the structure of a program without any actual coding or debugging.

In conclusion, “The .NET Tools Blog” has proved to be an invaluable resource for beginners seeking to grasp the essentials of PlantUML. As I continue my journey of using with this language, I anticipate returning to this resource for further guidance on creating readable and informative code diagrams.

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

Week of September 18, 2023

This week, I wanted to make a post showcasing some examples of documentation for free, open source software. Comprehensive documentation is essential for any software project, so I want to see what useful documentation looks like. I was inspired to make this post when I found myself in need of a new podcast app for my Android device. The one I had been using was no longer refreshing my subscribed podcasts when I opened the app, and I wasn’t able to load the episode lists of any shows. I needed a new podcast app, but I didn’t immediately want to download the Google Podcasts app that was at the top of the search results on their Play Store. I understand Google collects user telemetry and data from their apps, and I didn’t want Google to connect advertising data to my account from the ads many podcasts read from their sponsors. Ideally, I wanted a free and open source app I could use so I could feel more secure in my data privacy.

From Opensource.com, the definition of open source software is “software with source code that anyone can inspect, modify, and enhance.” Many open source projects are supported by communities of volunteers connected over the Internet. The benefits of open source software include stability over time, meaning that because the project can be maintained indefinitely by anyone, the software may remain compatible with modern systems for a longer time than closed source software. Open source software also promotes security for end users. Since the software’s source code is openly accessible, there is a greater chance that undesirable code is deleted or corrected once discovered.

Large-scale projects that require collaboration are supported by extensive documentation for end users. The example I mentioned earlier, AntennaPod, has a simple-to-navigate documentation page that begins with the basic act of subscribing to a podcast, and ends with instructions for podcast creators on how to have their podcast listed on the app through the use of existing podcast dictionaries. One interesting section I found was an explanation of centralized versus distributed podcast apps. Centralized apps are always in communication with a central server, and content is delivered from that server to your device. In contrast, distributed apps send requests to the podcast publishers directly, and do not contact a central server. This approach allows the developers of the app to devote more resources to maintaining and iterating on the app, instead of maintaining a server. Distributed apps are also a protection for user privacy, as there is no interaction with any central server to provide an opportunity to collect user data. The app developers don’t have access to information like which users are subscribed to which shows either. This decentralized, distributed approach also helps protect against censorship, because there are multiple sources to download shows from instead of one central server owned by one entity. Likewise, the app will continue to function even if development ceases, where in contrast a central app will stop functioning if the central server shuts down.

Sources:

From the blog CS@Worcester – Michael's Programming Blog by mikesprogrammingblog 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 jelbirt@worcester.edu !

Information/Source Links:

Post discussing use of AHK for coding: https://python.plainenglish.io/coding-faster-with-autohotkey-453a2face9af
AHK Home site: https://www.autohotkey.com/
AHK Method Documentation –
ControlSend: https://www.autohotkey.com/docs/v2/lib/ControlSend.htm
ControlClick: https://www.autohotkey.com/docs/v2/lib/ControlClick.htm
PixelSearch: https://www.autohotkey.com/docs/v2/lib/PixelSearch.htm
ImageSearch: https://www.autohotkey.com/docs/v2/lib/ImageSearch.htm

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.

How Progressive Web Apps Can Reshape How We Think of Web Apps

If we were to try to categorize all software applications into two groups (a bit of an ambitious task, but bear with me), we could separate them into apps that are platform-specific and natively-installed, such as apps downloaded from an app store onto a smartphone; as well as web-based apps, which run through a web browser. In the past, the majority of all applications can fall neatly into either category, each with it’s own advantages and disadvantages.

Historically, the most capable applications are those directly installed onto the user’s device. They can make use of the full use of system hardware, can launch regardless of internet connection, are more robust and reliable, directly read and write data stored on the device, and are their own platform. Native apps like Spotify, Waze, as well as more platform specific apps like iMessage, have the feeling of directly being part of their respective devices.

This is in contrast to web-based applications, which trade the capability and reliability of native apps for a design that is meant to be accessible to anyone, at any time, from any platform. Additionally, web applications have the advantage of only needing one codebase, as the only platform they must have compatibility with is just a web browser. While a developer of a native app may be able to create a more powerful and capable product, they must design and implement compatibility with each type of platform they want to run on. For example, the navigation app Waze must have compatible versions for iOS, Android OS, as well as other available operating systems.

This is now beginning to change, as Progressive Web Apps (PWA) have exploded into the field and promise to bridge the gap between platform-specific apps and web-based apps. Built using modern APIs, PWAs are able to fully realize their capabilities to the level of native apps, while still maintaining the reach and accessibility of web apps.

Authors Sam Richard and Pete LePage hit on the “best-of-both-worlds” abilities provided by PWAs in their article, What are Progressive Web Apps? “Progressive Web Apps are web applications that have been designed to be capable, reliable, and installable. These three pillars transform them into an experience that feels like a platform-specific application.”

While many different aspects of a developed application can be assessed and critiqued, the most important attribute of any app is the end-user experience. In other words, Is my app easy to use? Does it have all the features the user would need? Is it easily accessible? Reliable?

Progressive Web Apps cover all of these bases, and more. With the ease-of-access as a website and the capabilities of a native app, these new apps have the potential to reimagine how we think of web-based applications. While still a growing field, I believe the inherent ease-of-use provided by this platform will lead it to becoming a new standard for many different fields of application development.

From the blog Butler Software Construction, Design, and Architecture by Griffin Butler and used with permission of the author. All other rights reserved by the author.

First Post

Hello World! This is the first of hopefully many posts here… As a CS student I was tasked on making a weekly blog regarding my progress throughout the semester as I learn more stuff about software design through the course lectures, podcasts, and articles I find across my stay at WSU. I think this journal is a great idea. One thing I remember from a previous psychology course is that writing things down is a great memory reinforcement tool so hopefully whatever I jot down here I will be able to recall when I need it the most, not only that but I think that making this blogging thing a weekly habit will help me be more consistent on my extracurricular projects, because I must admit that I tend to neglect past projects whenever I start a new one, which happens often on a whim. This is the main reason why I added an archive, and made public a list of personal projects, so that in essence I am hanging my work on the wall ready for everyone to see, regardless if anybody actually sees it or not, the peer pressure I get from posting unfinished ideas will entice me to put more effort and love into them so that they stop being merely just ideas and become a finished product instead. Even if the quality leaves more to be desired, I must learn to finish what I start! So, in a sense, if this blog helps me be more consistent with my schoolwork as well as my personal projects, I would consider it a huge success. But I don’t want to stop just there.

I aspire to be a software developer one day, doing what exactly I am not entirely sure, but if there is any constant among every respectable professional out there is they all have some sort of journal that they share and discuss their findings as they develop new tools and design features for their projects (just like this school project!). Collaboration is a big part of this career, programmers borrow and share code all the time, so I think it’s fair play that we also share concepts and anecdotes with each other too. My goal with this website therefore is to join the cool kids club and write stuff down not only for me but for anyone that’s following my steps, of course there is not much to tell right now but who knows when it might prove useful one day.

I’ll stop daydreaming for now and get started

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

Should Software Architecture be Simpler?

Software Architecture is Overrated, Clear and Simple Design is Underrated: https://blog.pragmaticengineer.com/software-architecture-is-overrated/

Introduction:

Software architecture is a topic that has always fascinated developers and tech enthusiasts. It’s often seen as the backbone of any software project, the guiding force that ensures a system functions smoothly. However, the article titled “Software Architecture Is Overrated” by Gergely Orosz challenges this conventional wisdom. In this blog post, we’ll explore the relationship between software architecture and the article, offer a short summary, and delve into the reasons for selecting this thought-provoking resource.

The Relationship:

Gergely Orosz’s article, “Software Architecture Is Overrated,” is a bold statement that immediately makes me curious. The relationship between the article and our discussion is clear – it questions the importance and relevance of software architecture in modern software development. This article critiques the overemphasis on architectural design in software development, showing real-world experiences where being “by the book” with architectural principles may not always be beneficial. It also goes into the risks associated with excessive up-front planning and the potential benefits of focusing on simplicity, iteration, and feedback.

Summary of the Article:

In a nutshell, the article argues that while software architecture is undoubtedly crucial, it’s not the holy grail of software development. Instead, it suggests that agility, adaptability, and a pragmatic approach to problem-solving should be prioritized over rigid architectural dogma. Orosz shares anecdotes and insights from his own experiences, illustrating how a more flexible approach to software development can lead to better outcomes.

Reason for Selection:

This particular resource was selected for several reasons. First and foremost, it challenges a widely accepted fact within the software development community, sparking a debate that can lead to a more balanced perspective. Second, Gergely Orosz draws from his own practical experiences, making the article relatable and providing valuable real-world context. Third, in a world where software architecture is often glorified and overemphasized, it’s refreshing to consider alternative viewpoints that advocate for adaptability and down-to-earth software planning.

Personal Reflection:

This article has opened my mind towards making software architecture more strict and not as free flowing as the current culture makes it out to be. I do like simplicity when it comes to anything, but software architecture especially is key because of team work. When a team is meant to come up with a solution to a problem, you should be making things as simple as possible so all team members can process the information and act accordingly.

Conclusion:

In conclusion, software architecture is undoubtedly essential, but as the article “Software Architecture Is Overrated” argues, it may not deserve the exalted status it often receives. The relationship between the article and our discussion is clear, as it challenges traditional beliefs and encourages us to rethink the role of architecture in software development. By selecting this resource, we aim to stimulate critical thinking within the software development community and inspire a more balanced approach to creating software systems. It’s a reminder that, in the ever-evolving landscape of technology, adaptability and pragmatism should always be valued alongside architectural excellence.

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

Week of September 11, 2023

This week, I reviewed chapter 8 from Learning Java by Building Android Games 3rd Edition by John Horton. This chapter reviews some of the principles of object-oriented programming, including encapsulation, inheritance, and polymorphism. Interestingly, the principle of abstraction that was named alongside the previous three in the course syllabus is not reviewed in this chapter of the book. I chose to write about this resource because in the last Spring semester, I studied this book in order to create a functional mobile game in Android Studio for my final project in my Operating Systems course. I needed to apply my knowledge of arrays, for and while loops, and Java class design to complete this project. In addition, I needed to learn how to utilize the graphics libraries within Android Studio to visually represent the entities within the game and how they interacted with each other. While this book did help me tremendously in the later stages of the project, I wish I had found it earlier before I began coding. I had begun the project in BlueJ, and was coding a Java app meant to be run on a Windows or Mac system, not an Android mobile device as was the project specification. I completed a functioning version of the game with all the features I wanted to include that ran on my Windows PC, but I found it much more difficult than I anticipated to port the code I had written into Android Studio to produce a version of the game that would function on mobile devices. However, because I had applied the principles of encapsulation, inheritance, and polymorphism to my Java classes and functions, I was able to get the program to a partially functioning state on Android by the final due date. My first challenge in porting the project from PC to Android was addressing how to display the program on the device’s screen. Through this book, I found that constructing my Game class so it would extend Android’s Activity class would be the first step in displaying the desired output. I also applied the principle of inheritance to the Java classes I created to represent the in-game objects represented on screen. As many objects as I could manage inherited from a parent GameObject interface, which would be extended into more specific StaticGameObject and MovableGameObject subclasses, and then from those classes I extended them into specific types of objects like PlayerCharacter, Obstacle, and BonusItem. For my next software endeavor, I want to adhere to these principles more purposefully when coding, as I think that a lot of the challenges and headaches I experienced while creating this video game were self-inflicted.

If you want to try the game I made (I was so pressed for time by the end I never named it), here is a link to my Github repository. The project should be able to opened up and run from inside BlueJ or your Java IDE of choice.

Source: Learning Java by Building Android Games: Learn Java and Android from scratch by building five exciting games, 3rd Edition by John Horton

Github repository: https://github.com/MCummingsWSU/CS373-mobile-app-final-project

Screenshot of my game available at the Github link

From the blog CS@Worcester – Michael's Programming Blog by mikesprogrammingblog and used with permission of the author. All other rights reserved by the author.

New Blog, who dis?

Hi! My name is Tempura, I’m a college student currently attending Worcester State, going for a Bachelor’s in Computer Science. My pronouns are He/She/They, I don’t really have a preference.

I’m huge into video games and anything that flexes my creative muscle, which is why I’m going into a focus of Software Design and Development for my Junior year. I’ll be taking CS 343 and 348 with Professor Wurst, and as a part of that course, I’ll be starting this blog!

I hope to utilize this blog throughout my career, but for now I’ll be using it to go over what I’ve been doing and learning in my courses!

I hope you enjoy taking this journey alongside me!

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.

Welcome to TWTA!

Welcome to Tech. Worth Talking About (TWTA), a blog discussing exciting and impactful tools and innovations in the technology world, as well as some ideas on how to implement them in real situations to solve problems. Stay tuned for these posts and more!

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.

Principles of Software Design

Hello internet!

I’m Griffin Butler, and this will be my blog covering my learning experience during my CS-343 class. Here I will be discussing content related to software design, and I hope to further my understanding of how to create robust, efficient code in my projects and work.

From the blog Butler Software Construction, Design, and Architecture by Griffin Butler and used with permission of the author. All other rights reserved by the author.