
Note: It looks like we have to make 3 blog post for this class, in order to not clutter my posts page I'll just put them all here separated by a horizontal line. Also the section photo I 'believe' is public domain but I took it right from canvas lol. 

***

**Blog Post 1**

If it hasn't been mentioned previously, I'm Isaac. Like many of you in this class, I was previously working in the healthcare field before deciding to make the switch. For me, that involved trying CS50 online prior to enrolling here at OSU. Currently, I work part-time as a TA and full-stack developer at an eLearning company. Some of my interests include MMA, lifting, and video games. Unfortunately, this program and work are a bit time-consuming, so I've only been able to lift regularly and make time for hanging out with friends and family. However, as soon as this term is over, I plan to pick up a mix of judo, BJJ, and Muay Thai.

Regarding my future career, I think it will likely involve full-stack development or systems engineering. This is due to having positive experiences from my prior internships/work and really enjoying the operating systems class offered here at OSU. I am interested in the online master's program from Georgia Tech, but I plan to take some time off from school before diving back into it.

Regarding favorite capstone projects, the number one spot for me and my team is the cross-platform personal trainer app. This is due to our experience using some popular apps like 'Strong' or 'MyFitnessPal,' etc. 'Strong' is my favorite by far because it keeps the app simple by doing one thing only, and doing it well – tracking workouts. There are more features locked behind the pro version, but while useful, they're not necessary or particularly wanted (and $$$). Other apps just have a lot of ads and too much feature bloat, so why not make our own, strictly with what we want to include? 

*** 

**Blog Post 2**

In our journey to create a personal trainer app, React Native and Expo Go have truly shone as key technologies. Their blend of speed, cross-platform capability, and ease of testing has made them indispensable. React Native's ability to use one codebase for both iOS and Android has sped up development significantly, furthermore the learning curve has been great. I've only had to look up the very basics as they come up -> what are the html tag equivalents, what is a <view> etc. This enables us to spend more time developing and less on background learning. (Most of the learning has been for the noSQL DB and planning ahead regarding the workout suggesting algorithm) Expo Go's app + QR code scanning for development have been great as well. I've read a little bit about other development work flows requiring you to build / eject to native before running the app (without hot reloading either) and that just sounds tedious. The libraries around these tools have also been a huge support, just last week I was working on some of the reusable UI components and there was a ton of well documented libraries to pick from saving me most of the actual development. Just some quick styling customization and it was good to go. How could this technology be made better? -> honestly idk I don't have anything to add for this section.     

***

**Blog Post 3**

Some strengths of this course include its strict scheduling. Although I initially disliked working on weekends, our group could only consistently meet on Sundays for the progress report videos. This scheduling ultimately proved beneficial, ensuring a well-structured workflow. In the early weeks, aspects like project design felt rushed, but as the term progressed, the importance of dedicating a few weeks to project planning and task division became evident and immensely beneficial.

One area for improvement, in my opinion, is the clarity regarding the flexibility of the projects. Our group was initially drawn to the cross-platform exercise app, hoping to adapt it into more of a workout tracker—a tool we could actively use in our day-to-day lives. However, after receiving feedback, we realized that emphasizing the 'personal trainer' aspect was crucial, prompting us to adjust our focus slightly after the planning phase.

Another point of concern is the timeliness of feedback for assignments. We often received feedback on a progress report after having submitted the report for the following week, making it impossible to implement suggested changes. While this was not a major issue since it did not impact our grades (it was a minor issue), it represents an opportunity for course improvement. More timely feedback would allow us to make necessary adjustments to our progress reports or app in the subsequent week, especially for critical issues.

I cannot identify any threats to the course. Overall, my experience has been positive, largely thanks to my excellent teammates. The quality of one's partners can significantly influence the course experience, and I imagine I would have more things to say if it weren't for my great team. 

CS 467 blog 1-3


# Leveraging Next.js for This Blog

This blog uses a few features provided by Next.js, a React framework optimized for production web apps. Here is a short description of some of the core features powering this blog:

## File-Based Routing

Next.js simplifies routing with its file-based routing system. Rather than configuring routes externally, developers can mirror their intended route structure through the file structure. This approach boosts clarity, reduces configuration overhead, and enhances code organization.

## Pre-rendering 

In this blog I use static site generation - the webpages are built once at build time and served per request. This ensures fast loading and an SEO friendly website for search engines. With the incremental static regeneration option I can update webpages in the background ensuring content remains fresh.

## Image Optimization

Next.js automatically handles image optimization with lazy loading, resizing, and WebP support. Images load efficiently with minimal effort.


To be continued...

Nextjs-blog



Note: This is a rather quick explanation of my SMALLSH assignment, I'll update this later to be a beginer friendly tutorial including a why and how I reached the conclusions I did, what resources I used to get there and an explanation of the sytsem calls used. In the current state it's really just a highlight of some blog features like syntax highlighting.


A link to my github repo for your reference, this includes a testscript you can run, as well as a modularized version. [HERE](https://github.com/Isaac-Best/smallsh/tree/main)


**wordsplit()**

- Splits input line into word tokens
- Handles escapes, whitespace, comments
- Populates words array
```c
size_t wordsplit(char const *line) {
  size_t wlen = 0;
  size_t wind = 0;
  char const *c = line;
  
  for (;*c && isspace(*c); ++c); /* discard leading space */

  for (; *c;) { // iterate until NULL character 
    if (wind == MAX_WORDS) break;
    /* read a word */
    if (*c == '#') break;
    for (;*c && !isspace(*c); ++c) {
      if (*c == '\\') ++c;
      
      void *tmp = realloc(words[wind], sizeof **words * (wlen + 2));
      
      if (!tmp) err(1, "realloc 1");
      
      words[wind] = tmp;
      words[wind][wlen++] = *c; 
      words[wind][wlen] = '\0';
    }
    ++wind;
    wlen = 0;
    
    for (;*c && isspace(*c); ++c);
  }
  
  return wind;
  }
```

**param_scan()**

- Finds parameter tokens like $!, $$, ${var}
- Sets start and end pointers for each

**expand()**

- Expands parameters like $!, $$ with values
- Uses param_scan() and build_str()
- Returns expanded string

**build_str()** 

- Helper to build up expanded strings
- Appends strings/ranges to base string

**tokenize()**

- Parses I/O redirects, background ops  
- Builds argument array for execvp()

**check_builtin()**

- Checks for builtin commands like cd, exit
- Provides custom handling

**execute()**

- Forks and executes commands
- Manages I/O redirection
- Waits/handles child processes

**manage_background()**

- Checks and handles completed background processes

**reset_flags()**

- Resets I/O redirect flags for next loop





All Post

CS 467 blog 1-3

Nextjs-blog

Small Shell Implementation