Thrown Into the Fire — Learning Containers as a New College Grad
Graduating from the University of Nevada, Reno — 2019
In 2014 I started at the local community college with my general classes while figuring out what to do with the rest of my college career. Eventually, I tried Computer Science 135 and loved it; I went wild in thought about what could be built with code.
As I kept progressing through school, I found myself trying to take more game development, AI, and Machine Learning classes.
Traversing down this road, it was mind-blowing where AI and ML was being applied: self-driving cars, drone flying and avoidance systems, etc. I felt myself putting my dream of game development aside for another, to help develop and further these new technologies that would, and currently are changing the world.
One of the last classes you’re supposed to take at my university is Software Engineering, a two-semester long class where you design, document, and build an application of your team’s choosing. This was our opportunity to learn new technologies, develop something usable/modern, and really test the skills that we’ve learned over our college career.
I joined a team where we would re-develop an existing WordPress application that was being used in production. Having only worked on school assignments up to this point, the prospect of building a platform that would be used by tens or hundreds of people both scared and excited me, but we were all up for the challenge.
The new application needed to be easily scaled and maintainable for future seniors adding to the project. We decided on a micro-service architecture using modern technologies like React and Node. Most importantly though, this would be my introduction to containers.
My team consisted of three people: Nikkolas, Anthony, and myself. Anthony had been working an internship where React was his primary focus; he took on the role of project manager. Nikkolas’ interest was in back-end development and database management. Lastly, I filled the the slot of front-end developer.
Anthony took on the role of project manager, giving him the opportunity to structure our development pipeline. Like others in my class, Docker was a technology people wanted to use and learn, so he took it upon himself to not only learn Docker but to pair it with Kubernetes.
As a team, we spent the first couple weeks meeting with the client to go over the existing WordPress platform to determine which features should be brought over and what new features they would like implemented. Individually, Nikkolas and I learned React, and Anthony sacrificed sleep to research and implement K8s and a CI/CD workflow.
Our goal was to mock out views to get an understanding of how the new platform would need to feel and be styled. This way, when our DevOps pipeline was ready, we could hit the ground running and meet/exceed content delivery timelines.
With one final semester to complete, I entered into the panic a lot of seniors face: the job hunt. Dozens of applications for an internship and only a handful of interviews, but no luck. I kept questioning myself and wondered about a job after completing college.
Fortunately for me, at the beginning of the semester, I was contacted by Alexander Mattoni, CTO and co-founder of Cycle for an opportunity to be a part of the team as a front-end developer.
My first task was to create a flashcard application. This would test and build upon my React experience from school, show how quickly I could learn Redux, creating a simple API, and interacting with a database. The goal was to get me familiar with the technologies I’d be using on the job. This project went through several different iterations and at one point I scrapped the whole thing to rebuild it, reusing only what was necessary. My final task was to deploy the application using Cycle.
Before working on this project, I still hadn’t actually touched a container, let alone how to write a Dockerfile properly for one. I didn’t even know how to use containers to run my development workflow. I’d run
docker compose up --build in my school project, but I wasn’t sure what it did or why. I ran through tons of tutorials, different articles, or looking through different GitHub projects to figure out how to set up my Dockerfiles and Docker Compose to run locally.
One of the issues I ran into, early in the project, was that my containers would immediately exit. Everything I found online was recommending adding the flag
-it to the run command, but still, the container would stop immediately. I tried a variety of configurations that I lost track of what worked or why.
- How would I set up a production-ready container?
- How would I handle setting up a domain and pointing it to my application?
- How am I going to handle networking and communicate between my containers?
These are questions that I should have asked myself, but I never actually even had to think about them — they were handled for me. I didn’t realize how many steps of app deployment I skipped until it was pointed out to me.
In fact, I didn’t even need my docker-compose configuration. I was able to import my already made images into an environment in 10 minutes. With Cycle, I never had to worry about these topics and several more where they’re typically done manually.
Having now worked through different projects, applications, or even seeing how Cycle runs and connects all of its services together through containers, I truly see the power of containers and Cycle.
Containers improve the development lifecycle, but they’re only as effective as the tools you pair them with. This is what made me appreciate Cycle, taking complex pieces and making them simple for everyone to use. I’m super excited to be a part of the team and getting able to deliver new, amazing features.
If you want to dive in and learn more, head over to our slack channel. Our community is growing, and our team hangs out there daily. Feel free to shoot us a message any time with your questions and we’ll be sure to respond!
Of course, for a more in-depth look at how to use Cycle, check out our documentation.