Senior Year as a CS Major

Last quarter of the degree! Less than 10 weeks to go from now and I’ll have finally finished my B.S. in CS – I’m really excited for that moment. We’re so close to the end with our capstone. We’ve fixed some major issues lingering from last term and we still have some things to add but we’re definitely approaching the “wrap up” point. Unless major issues come up that take priority, I’m looking at developing the documentation (user guide and research compilation) in our team’s second sprint so my work on actual software features is nearly done. I will be making the documentation in the form of markdown or HTML to make it user friendly and easily navigable so I’ll still be developing in that sense.

For today, I wanted to do a kind of retrospective on the technologies I’ve used over my degree and think about which ones I’ve developed real proficiency in, which were my favorites, and which I’m hoping to work with more in the future.

IDEs/Editors:
Dev-C++
Netbeans
Replit
Jupyter Notebooks
Spyder
PyCharm
Notepad++
Vim
Visual Studio
Visual Studio Code
DrRacket
Android Studio

At this point, my most comfortable IDEs are Notepad++, PyCharm, and Visual Studio. I can easily use Android Studio and Visual Studio Code but I don’t like them as much. I actually hated Visual Studio Code for a long time because I had really only experienced using a different IDE for each language before that and I felt like it was a jack of all trades master of none IDE. Replit was a great solution especially when I was starting out with my community college classes and just getting used to coding. I actually got to really enjoy using Vim and would like to use it more in the future to get more comfortable! Dev-C++, Jupyter Notebooks, and Spyder I could figure out given some time, but they also haven’t made a big impression on me. DrRacket was easy to use and helpful for learning about functional programming. I would certainly use it again in its context. Finally, I used to be so proficient with Netbeans but it’s kind of a nightmare to use and I don’t miss it at all or have any desire to go back to it!

Languages:
Java
C++
Assembly
HTML
CSS
JavaScript
Python
C
Ruby
Racket
Prolog
Raku
SQL
C#
Kotlin

Wow, I’ve really used a lot of languages! My strongest languages are C, C++, Python, HTML, and CSS. I’m pretty good in C#, JavaScript, Java, SQL, Raku, and Ruby but those are languages that I know I’d have to look things up in and reacquaint myself to to use successfully – and Java was originally my strongest language, I used to be great in it and have done GUI applications and an Android app in the past. It’s just been so long since I’ve used it. I loved working with Prolog and Racket and I want to get so much better with both of them – and with functional and logical programming in general. I’m planning to work through a Prolog textbook after graduation to really dive into it because it just appealed to me so much and made so much sense. Assembly and Kotlin are my worst languages for sure and not ones I really have much interest in. I don’t actually like doing app development (I’m not a big fan of doing front-end work) and I really don’t like working as low-level as Assembly. They were both good to be exposed to, but also good to figure out that I’m not interested in pursuing that direction of CS.

3rd Party Software/Services:
Git/Github
Maya
Blender
Unity

I couldn’t think of nearly as many of these. Obviously there are other things I’ve used in the course of the program, like MS and Google suites but I was so familiar with them before I came back to school that it doesn’t make sense to me to list them here. I’m very proficient in them – I’m a Microsoft Word and Excel expert – so those are definitely strong skills. Using Git with and without Github has been such a valuable skill I’ve developed in my coursework. It’s definitely easier for me to version control with the Github Desktop interface but if I really needed to I could do it in a CLI, but would need to double-check commands. I actually felt like I got pretty good at Maya in the NMC class I learned it in, but it’s not something I feel like I could just dive into now without outside assistance and I would need to kind of warm up. Blender is something I feel a little more comfortable with but I’m nowhere near proficient. I really want to get better at both of these and plan to spend free time making 3D models and growing that skillset. Finally, Unity has been interesting to work with. I haven’t totally loved the experience and the documentation has been out of date in so many areas, but I think it’s been valuable to get used to and I could see myself growing a lot with it by doing some small, varied projects on my own.

Looking back like this I can really feel how much I’ve learned since I came back to school in 2020. I’m sure I’m even forgetting some technologies I’ve used as I write this, but it’s kind of an incredible amount. I’ve felt imposter syndrome a lot throughout this degree but it gives me some confidence to see all of the things I’ve worked with and know my strengths and weaknesses and know that I can (and want to) grow even further in some areas.

The end of Winter term is here! My group has made a ton of headway into our project and we just have one term to go to finish it up. That will mean graduation for me and moving on to my overseas internship the weekend of graduation. A lot of big changes but I’m prepared to tackle them!

Over this term I learned a lot and did a lot. We have essentially completed the MVP of our product, resulting in an alpha version that has all of the functionality we were looking to implement.

What was the most difficult challenge, and how did you solve it?

My functional work for this term was split into three different major requirements: reproduction, death, and the energy cycle (which is intertwined with predation as part of death). These were each challenging in their own way, but for me from the perspective of managing the organisms, the energy cycle was the most challenging. This involved a lot of research into real-life energy cycles for both plants and animals, because our product is intended to be an educational tool to learn about biological processes of evolution. Since our work needed to reflect reality in this way, it involved a lot of learning about these processes, which I had some small knowledge of from introductory biology classwork, but I didn’t know the intricacies or the actual numbers/percentages of energy consumption, storage, and loss. I was able to implement a framework for this and fill it with numbers based on my research. To some extent, because this is just a simulation and we have not implemented every intricacy of energy usage for every kind of organism, I did have to make some decisions about the ways energy would be impacted by the traits that we implemented. Ultimately, the numbers are changing and will probably continue to change over the next term as we add in additional factors from our stretch goals, because this is such an important base for a lot of the simulation requirements.

Ultimately, I’m very happy with all of my work this term, and I feel great about having gone through the learning process to be able to implement functionality the way I envisioned from the start. I’m really looking forward to continuing to finetune our work and add in new elements to create a great finished product by the end of the school year.

Capstone Technologies

Working on this capstone has given me the opportunity to learn and apply a couple of new technologies. My capstone project is all about artificial life. Our goal in relation to this is to develop a simulation of evolution over time, with artificial species having genomes that produce inherited traits, where the simulation demonstrates how, over long periods of time, those species reproduce, mutate, and speciate. We have chosen to complete this project using Unity and C#, both tools I had very little prior experience in.

While I hadn’t actually worked in C# before this project, I have found it very easy to pick up and I have been enjoying learning it! I have previously done a significant amount of coursework in C and C++, both at OSU and at my community college, RCC. This made learning C# a pretty simple task. There have been some minor differences, but I’ve found the documentation pretty straightforward and that has helped me a lot. I’ve even learned some little tricks associated with C# like auto-implemented properties!

Unity, on the other hand, has been a bit more challenging. While I worked with Unity in a previous NMC course, my experience was very limited and did not include scripts. Combining Unity with C# scripts, and adding in the challenge of a group programming dynamic has been relatively difficult. I have not found Unity documentation to be nearly as helpful as C# documentation. For example, when trying to figure out how we would implement group version control for our project, we went down some rabbit holes of Unity-associated VC methods. This resulted in several dead-ends with outdated documentation and deprecated systems. This wasted about a week of our time last term and we ended up figuring out a system with GitHub instead that has served us pretty well so far (though we have seen a couple of merge issues pop up). Luckily, I am not in charge of the UI for our project, as that seems to be the steepest learning curve, and the team member who is has had a lot of experience with Unity on other projects.

Overall, I would say that I’m really happy with our tech stack. We definitely discussed other possibilities, but I think with the team that we have, this option has made the most sense and will produce the best product in the end. I’ve really appreciated the opportunity to add these technologies to my arsenal and hope to have the opportunity to use them again and grow my skills in future projects.

Winter 2024, the start of CS 462!

I chose to read this article on clean code
and this article on code smells.

What is one thing from the articles that you would like to start doing (more often), and why? What is one thing you want to avoid doing and why?

An area I always strive to improve in is applying comments strategically. I have vascillated (but, I think, improved overall) in my commenting style since I started going to school for Computer Science. In my lower-division classes, I developed really poor coding practices in that I rarely, if ever, actually commented. In part, this habit developed because the initial programs I was coding were so simple that they could easily be deciphered without comments, but because I didn’t correct this early on, it continued to my more complicated code. The code snippet below is an example from one of my early programming classes that could sorely use some commenting:

if (rr + rw >= 1)
{
   for (int i=0; i<set.size(); i++)
   {
      string temp = set[i];

      if (temp[0] != n1000 && temp[1] != n1000 && temp[2] != n1000 && temp[3] != n1000)
         set.erase(set.begin()+i);

      if (temp[0] != n100 && temp[1] != n100 && temp[2] != n100 && temp[3] != n100)
         set.erase(set.begin()+i);

      if (temp[0] != n10 && temp[1] != n10 && temp[2] != n10 && temp[3] != n10)
         set.erase(set.begin()+i);

      if (temp[0] != n1 && temp[1] != n1 && temp[2] != n1 && temp[3] != n1)
         set.erase(set.begin()+i);
   }
}

When I realized that this was an issue that really needed correction, I ended up overcorrecting and used comments a little excessively (a better problem to have, but a problem nonetheless). The following code snippet is an example from a later course with some truly unnecessary comments:

public class MonthDays
{
...
  //constructor for class
  public MonthDays(int month, int year)
  {
    setMonth(month);
    setYear(year);
  }
...
  //retrieves the month
  public int getMonth() 
  {
    return month;
  }
...
  //returns the year
  public int getYear() 
  {
    return year;
  } 
...
}

I feel like I’ve improved a lot in my commenting practices at this point. Functions and blocks of logic generally have a comment quickly explaining their purpose, non-obvious bug fixes have comments explaining why something needs to be a certain way to avoid repeat mistakes, and blocks of code with similar functionality will have one accompanying explanation comment. I know though, that I still tend to overcommenting and it’s something I actively try to be aware of and will continue to try to improve going forward.

A practice I would really like to avoid is long parameter lists (#9 on the code smells article for reference). I chose this because it’s honestly something I’ve never thought about before, but is something I’ve noticed in code I’ve used (like imported classes or skeleton code). I do think I’ve done a pretty good job of staying away from this in my own code naturally, but I’d like to be more cognizant in avoiding it intentionally going forward.

The article makes a great point that if your parameter list is too long, your function is probably doing too much. But for me, the biggest issue comes with usability. Long parameter lists make it challenging to use a function. The programmer has to consider too many things – “What order do these go in?” “Which arguments are needed for this call?” “What types are used for which variables (especially when looking at number types – is it a decimal, float, int, double)?” If I have to look at a function header 3+ times to get all the parameters in, it’s most likely too long to be practical.

As an example, the crosstab function in the pandas library is, in my opinion, challenging from a usability perspective because of the number of parameters used. Below is the function header, but here is the doc page for reference.

pandas.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, margins_name='All', dropna=True, normalize=False)

These were some great examples of what to be more mindful of in my code, but reading through all of the other best practices on clean code and code smells were incredibly helpful as well. I think just having taken the time to think through all of these will make me more mindful in writing and reviewing my work.

Closing out the term.

I can’t believe another term is almost finished again already. This quarter I took CS 450 Computer Graphics, CS 321 Theory of Computation, and CS 469 Real World Project Management (in addition to CS 461 Senior Software Engineering Project – capstone – of course).

I’m happy to report that just ahead of my last assignments and finals, I have all As – an I hope to keep it that way! I’ve learned so much this term. CS 461 has taught me a lot about preparing for large-scale team projects and project managament. CS 321 has brought me back to proofs and gotten me much more comfortable with them, and made me so excited about Turing machines that I couldn’t help but share some basics with my husband. CS 450 has allowed me to be creative with my code, and I already have more graphics projects in mind for working on in my free time after the term. CS 469 has given me the opportunity to work on a fun side project (I made a pretty simple clicker game) that I look forward to adding on to in the future. I’m really happy that I took care of some of the more dense degree requirements earlier on and saved interesting and fun electives for my senior year. I feel like it’s been great for combatting any senior fatigue I have because I’m excited to go through course material and to create projects.

I’m looking forward to next term, where in addition to CS 462, I’ll be taking CS 457 Shaders, CS 492 Mobile Software Development, and CS 391 Social and Ethical Issues in Computer Science. Excluding 391 (which I am still excited about – there are so many ethical questions in the world of computer science right now), these are electives again and I’m so happy about my schedule.

I’m feeling really motivated right now – in all honesty, I usually am at the tail end of a term – and I’m working quickly to finish the remaining assignments and projects I have left. I’m hoping that this motivation will carry through to the next term and make the time fly by! I know my last quarter will be a breeze just because the end will be so close, but at six months out I still need a bit of a push to really feel like I’m really this close to getting my degree.

Looking forward to enjoying the winter break and some holiday time out around Korea and at home, best wishes to everyone out there and hope that your break is also safe, relaxing, and fun!

Hello again!

Now that we’re past the halfway point of Fall term, I feel so much more confident about the rest of the year ahead. My team communicates well and we’ve been able to divide work so far well according to our own strengths, which is great! I really feel that each of us brings unique skills to the table that help us to be more successful at each deliverable stage. We’re all excited about our project, which has been really nice. A good lesson for me in our work so far is that it’s easy to get carried away adding features and functionality on a project you are really interested in. Luckily, between discussions amongst ourselves and with our mentor, we’ve been able to pare things down to a really nice minimum viable product with plenty of stretch goals to keep us going if we really hit a roll with development. That’s been a great team experience for me that I’ll keep in mind for the future.

Career-wise I have some exciting news! Our fellowship cohort finally (yesterday) received the list of potential overseas internship placements for Summer 2024. As I live in South Korea, I have been doing my best to advocate for the possibility of going to Seoul for my internship (avoiding incredibly expensive travel costs that would be my responsibility). I’m happy to report that it was on the list! While it isn’t a guaranteed placement for me, the possibility now definitely exists, and I hope to get it. Otherwise, there are some nearby options in Asia that I hope to get, so we’ll see! I won’t have news regarding a tentative placement until likely mid-December, so probably not in time for an update here, but wish me luck! Summer 2023 was a domestic internship for my fellowship in Washington, DC. It was fun and an exciting learning experience, but the overseas one next year will allow me to see what my career for (at least) five years following graduation will be like. Everything I’ve heard from previous cohorts about the overseas experience has been extremely positive, so I’m getting really excited about the next adventure!

Still lots to learn in the meantime, so I’ll try to keep plenty of focus on the rest of the school year (though also happy to report that this term has been great for all of my classes so far, all A’s for now!).

Hello out there! I’m Jolene and I’m (finally!) a senior at OSU this year in the CS Ecampus program. I’m feeling so excited to be in my last year of a BS after such a long educational journey. Starting capstone and finding a group/project has been kind of a jarring realization of “Wow, I’m really almost done!”

This summer was really out of the norm for me and was my first taste of what life after my degree will feel like. I’m in a fellowship program (FAIT) with the Department of State and have a guaranteed job for at least five years after graduation – longer if I want it (and get tenure). This summer was the first of two internships for the program and it was my first time not taking classes for a session since I returned to college in the summer of 2020. It was so different to not have homework to work on or tests to study for and to show up in person at a “career” job. I’ve worked in a lot of sectors (education, accessibility, customer service, quality assurance) but I never did anything that I felt like I could see myself staying in for the long term (10+ years). Deciding to get a degree in Computer Science has been the big catalyst to change that for me and I’ll probably be doing work related to the field until I retire.

I can’t wait to knock this quarter – and then the next two – out of the park and get going on the next phase of my life! I love learning and plan to get an MS in the future and maybe even go beyond that, but I’m also looking forward to learning about my new job and focusing my efforts on that next year.