If you're in CS, you really don't have a choice here. A large part of your education in CS will be to learn about algorithms against data structures, and measuring complexity. Do your best to gain an intuitive understanding of why these things actually work.

I was blessed to have a curious little brother, so a natural framework I use is to distill these things into something a child could understand. So, for example, why does a (balanced) binary search tree have a O(log n) search time? It's not immediately clear how log fits into the picture as most people usually study logarithms in a calculus context. If you're educated in this area, do try to come up with a good, simple explanation. I would probably say something like: Well, log can be used to measure how many times we can halve something³, and if you follow an example, you'll notice that we cut the tree in half each time as we search, until we reach the bottom. (with lots more elaborations)

If you're not in CS, pick these things up. There are a dizzying about of material elsewhere about this, so my recommendation is to pick a popular introduction to CS and finish it. Then work your way up. Then this stuff will apply better.

So, my advice is:

1. Study and be able to reproduce common algorithms/data structures.
   1. E.g. Can you sort a list of integers? What's an appropriate way to do it? Merge sort, radix sort, heap sort, quicksort? (hint: almost always quicksort)
   2. E.g. What's a linked list? What's a stack? What's a tree? What's a graph? What's a hash table? How can you use these primitives so model problems? Which ones would you choose?
   3. E.g. Here's some spaghetti code, what's the time complexity of it?
2. Understand, and recognize, the importance of converting data structures into other ones. (you most certainly do this all the time).
   1. Why do we convert data structures into one another? What's the advantage of converting a list of words into a radix tree? When is it worth it?
3. Study the memory requirements of data structures/algorithms. This is a science after all, so practical applications are sometimes necessary.

This actually pretty easy if you're curious about this stuff. Industry languages tend to be the most popular languages, so you've already picked one up. Proficiency is only gained through practice⁴, so keep at making programs. Once you've gained enough experience, the world is your limit. There are few other professions where the cost to entry is so low. Don't like something? Screw it, make your own.

Similarly, industry tech tends to be popular ones. I do recommend using Linux or at least some Unix environment. UW's CS club fee is like $2/term, and you get access to a bunch of Linux boxes. Even better, install Linux and use it as your daily driver. You'll find some rough edges you'll need to program around. Besides, it's vital to be comfortable with the command line. It's by far the most productive environment, especially when you hit a wall in your GUI editor (plug: emacs). You will probably want to understand how to traverse the file system, copy files, and pipe bash commands together.

Other bits of popular industry tech include docker, react, Django, etc. Look around online for popular frameworks and tools.

As mentioned above, there's a reality-warping field in the tech industry which has divorced the industry into the holy trinity of the Resume, the Interview, and then the actual Work.

There's an immense amount of advice on the internet about all three of these, but here's what personal experience has taught me:

Resume:

1. It must stand out visually but must be familiar.
2. Be as concise as humanly possible, and convey what you accomplished.
3. Use active voice. If can stick "by zombies" at the end of the sentence, it won't feel good to the recruiter.

Interview:

1. Practice beforehand; map your skills and experience to the position.
2. Get comfortable with getting stuff wrong. You won't always get the question the instant it's asked. They'll help you, and learn more about you.
3. Communicate communicate communicate, if you need a second to think, tell them.

Actually working:

1. Be yourself, but don't be a know-it-all.
2. Ask questions. Fuck up. Learn. That's the point of co-op.
3. Dress nicely and be friendly. If you're introverted like me, take the effort to get to know your co-workers.

Before I get into this, I highly recommend using LaTeX or similar templating tools. The websites are nice and easy, but everyone uses it so you may not stand out. I keep my templates in source control and as its text, I can do dirty things to it with emacs.

This is probably my most complex template, as it contains several hundred lines of commented out sections that I add in or remove depending on the context. For example, my resume source has a bunch of these blocks:

%% \entry
%%     {2015}
%%     {REPORT ON TECHNOLOGY IN THE CLASSROOM (MSAC)}
%%     {}
%%     {I coordinated, managed, and shipped a report on technology in the classroom to the Ontario Minister of Education. \\
%%     Key Skills: \textit{Effective Communication, Problem Solving, Analytical thinking}}

Depending on the job or position, I toggle these sections to better fit my resume to the job. I then compile it and submit it.

Of course, a template also has to have variables. This is pretty easy in LaTeX. In my cover letter, you'll find a bunch of things like:

\newcommand{\positionTitle}{Developer}
\newcommand{\recruiterName}{Hiring Team}
\newcommand{\companyName}{COMPANY}
\newcommand{\sppp}{\hspace{20pt}}

And use it like this:

Regarding the \positionTitle{} position currently advertised on

Obviously, for more important applications, I add new handwritten sections and save them for future use.

This one is pretty easy if you're using org-mode. I usually just copy/paste the header of a previous assignment, which looks like:

#+TITLE: CO487 - A2
#+AUTHOR: David Briggs (09876432)
#+EMAIL: [email protected]

#+OPTIONS: toc:nil num:0
#+LATEX_HEADER: \usepackage{mathtools}

\setlength{\parindent}{0em}
\newcommand{\eqdef}{\vcentcolon=}

Otherwise, you'll probably need to use LaTeX for your CS assignments. Develop a common enough document and reuse it later.

If you're not familiar, at UW, you need to write a report on something relating to your work term. The grade weighting is all messed up, and the format is weighted as much as the content itself. So, if you have a perfectly formatted template, you can write a few thousand words of hot garbage and pass the assignment.

So, I built an extensive, nearly perfectly formatted template with LaTeX and org-mode. Nearly everything is automated. So when I need to write one, I fill in the variable section (see below), and then spew bullshit.

\newcommand{\theTitle}{Neato Documentation and Tutorial}
\newcommand{\bossCalling}{Mr.}
\newcommand{\bossFirst}{Foo}
\newcommand{\bossLast}{Bar}
\newcommand{\companyCity}{Waterloo}
\newcommand{\companyCityProvince}{\companyCity{}, Ontario}
\newcommand{\companyName}{SomethingInUW}
\newcommand{\companyPostalCode}{N2L 0Z0}
\newcommand{\companyProvinceShort}{ON}
\newcommand{\companyStreet}{Something Dr}
\newcommand{\currentProgram}{Computer Science}
% … snip (more variables/latex) … %

And that's it. Develop one of these templates in your 1B coop and it'll pay dividends for years to come.