Week 10 – CST499 Fall 2025 Capstone This week, our team continued making improvements on the crawler and the summarizer. The crawler has a more robust whitelist.yml file that includes additional link seeds, broadening the scope of Nanjing-related links it can crawl. The summarizer now uses the LLM to first generate an English summary, which is then translated into both traditional and simplified Chinese. My main focus this week was on improving the UX/UI design for the wiki site. We decided to implement a wiki site that closely resembles the client’s existing site. This idea came up because their current wiki page theme and color palette complements the rest of the pages on their website. The wiki site now has most of the same functionality as their current site. Users can click on a summary title in the “Recent” tab which renders a corresponding tiddler in the story river. Users can also edit these tiddlers or they can generate their own tiddlers. Additionally, users can save any ...
Posts
- Get link
- X
- Other Apps
Week 9 – CST499 Fall 2025 Capstone This week, our team made significant progress on the summarization pipeline and publishing for our project. We successfully connected the summarizer to a local LLM running on the client’s computer via an API. This setup allowed us to generate summaries much faster, which helped us efficiently test and refine the summarizer’s output. On the publishing side, we implemented a working TiddlyWiki page that displays the generated summaries as tiddlers. Each summary appears in a “Recent” list, and clicking on a title opens its corresponding tiddler with the full summary. Marcelo handled most of the code for generating the HTML file using the TiddlyWiki CLI, while I contributed by designing and implementing a CSS stylesheet and theme to improve readability and give the site a cleaner appearance. The website now meets the requirements for a minimum viable product (MVP), though we plan to continue refining it. Next week, we plan to focus on UX/UI i...
- Get link
- X
- Other Apps
Week 8 – CST438 Software Engineering List the 5 most important things that you learned in the course, and why you chose them. This course provided us with a comprehensive list of modern tools and practices for software engineering. We covered topics ranging from development methods to cloud deployment. The five most important things I learned in this course include Agile development, Plan and Document development, using GitHub for version control, using Spring and React along with Selenium for writing software, and AWS deployment. Learning how to apply Agile project development along with Behavior-Driven Development and Test-Driven Development gave me a deeper understanding of how to design software with the user in mind and ensure proper functionality through early testing. BDD helps ensure that the final product meets the expectations of stakeholders and TDD helps build confidence in the project by writing tests first. These practices encourage maintainability and reduce ...
- Get link
- X
- Other Apps
Week 7 – CST438 Software Engineering Describe some of the differences between using an Agile process and using a Plan and Document (or Waterfall) process. The are many differences between using an Agile process and using a Plan and Document process. Some of the more noticeable differences are found in their approach to planning, flexibility, and team structure. In an Agile process, development planning is iterative and ongoing. The project is broken down into short cycles called sprints that lasts one or two weeks. In P&D, the planning details are set for the entire development before any work begins. This is because each phase relies on the previous phase being completed, like a waterfall. Flexibility in an Agile process is high. The stakeholders are actively involved in the process to ensure the product meets their expectations. They provide continuous feedback which may change the project requirements. Due to the iterative nature, it is easier and...
- Get link
- X
- Other Apps
Week 6 – CST438 Software Engineering Write a weekly entry describing important things you learned this week. This week we read chapter 25, Compute as a service (Caas), from Software Engineering at Google. This chapter covers how Google uses compute as a service to abstract hardware issues which allows developers to deploy software without having to worry about the constraints of physical infrastructure. The chapter also brings up the concept of pets vs cattle. In this analogy, if your server is a pet, it is expected that you will look after it and nurse it back to health if something goes wrong with it. If your servers are cattle and something where wrong with it, you would use automation to replace it with a new one. They use this analogy to explain that developers must embrace the cattle and not pets mindset to make software scalable, resilient, and idempotent. From our assignment, Iteration 3 System Test, I learned how to deal with finding repeated React components that contai...
- Get link
- X
- Other Apps
Week 5 – CST438 Software Engineering Summarize in a few sentences what you have learned this week. From our textbook, this week we learned about larger testing. Large tests cover things that unit tests cannot. Unit tests make use of test doubles to eliminate hard to test dependencies. Issues can arise when replacing doubles with the real thing. Unit tests are also limited to the imagination of the engineer who writes them. This means that the test will only test for anticipated behaviors and inputs. In the real world, users come across unanticipated issues. Another detail restricting unit tests is the environment in which it is implemented which is designed to be fast and reliable. This deliberately eliminates the chaos of real dependencies, networks, and data. In contrast, large tests provide reassurance that the overall system works as intended by verifying the behavior of the system in a more realistic environment. From our group project (iteration 2), I increased my underst...
- Get link
- X
- Other Apps
Week 4 – CST438 Software Engineering What is the most interesting thing you have learned in your reading of "Software Engineering at Google"? I really enjoy reading our textbook “Software Engineering at Google.” It covers software engineering topics in detail, and it demonstrates how it is implemented in the real world by one of the biggest tech companies today. So far, we have covered the topics “What is SE?” (Software Engineering), “Testing Overview,” and “Code Reviews.” All chapters have interesting information that is relevant to the course. From “What is SE,” I learned the difference between “software engineering” and “programming.” Programming is about producing code and software engineering is the maintenance of that code for the duration of the code’s lifespan. We must produce sustainable software which requires us to respond to changes in dependencies, technology, or product requirements. From “Testing Overview,” I learned that testing is essential to produce...