Software Development

Your degree isn’t enough: my advice to students

by

A degree, whether it be in computer science, software engineering, mathematics or a related field is often marketed as the golden ticket for those wanting a lucrative career in programming. An often extortionately expensive goose that will eventually lay golden eggs for years to come.

While it’s absolutely true that a degree has serious value in technical career paths, it should be noted that students on a degree programme should not see three to four years of study as a silver bullet. Plenty of students will get a job with just their degree and nothing more, yes, but as the barrier of entry to many development and IT jobs lowers and university students face increasing competition from apprentices, boot camp graduates, and completely self-taught developers, there is no room for complacency.

What do you know?

Throughout my time in academia, I’ve had the good pleasure of advising plenty of students on their next steps and what they can do to maximise their time as an undergraduate. I’ve been on careers panels, representing former employers and universities. I’ve had the opportunity to learn directly from senior developers and recruiters from a range of amazing companies including Google, Oracle, Amadeus, and Network Rail on what they’re looking out for and how they curate CVs (resumes). I currently work in education now; passing the mantle and routinely guiding and assisting students with their own professional development and learning journeys.

Of course, don’t accept my word as Gospel. I encourage you to do your own research, talk to your university’s career service(s), and to other senior developers and recruiters you network with. Everyone has unique perspectives to share and your mileage will always vary. Finally, it’s important to note that I speak from the perspective of someone within the British education system, so things can be different elsewhere, such as in Africa or in North America.

A tiny word of caution

I realise that by writing this article some might try to mimic me directly or curate my GitHub or other portfolios to see whether I can stick to my own advice.

Do what I say, not what I do.

I’m not always a great model to follow directly, given that my intentions have always been different and that I never intended to work as a full-time web developer given my interests and passions lie elsewhere. I’m an academic first and foremost. That being said, I routinely help people reach those goals, so let’s get started.

1) Complete projects and portfolios

You hear this all the time on self-taught guides and other tutorials on how to work in software engineering or to become a developer. Students with a formal CS background are not exempt from this. University teaches computer science and a lot of theoretical skills, with practical elements here and there. It often doesn’t teach you how to use the latest frameworks and programming languages, which are nevertheless in high demand.

You will often be grilled on how you’ve applied your programming knowledge outside of work/studies and this is a great time to show off the work you’ve done. Uploading your coursework to GitHub isn’t enough here either, though it’s certainly a start. Whether it’s design work, APIs, monolithic web applications, JAMstack websites – whatever – show it off and be prepared to talk about it.

2) Contributing to open source

A quick word on open source. Open-source contributions are frequently seen as brilliant and often favoured even more highly by many recruiters and interviewers as they demonstrate a working knowledge of development workflows and current technologies. That and you know how to confidently use Git.

That being said, contribute to (F)OSS if it interests you. Don’t feel pressured into contributing to a project if it honestly just doesn’t interest you that much. Or worse yet, for a damn t-shirt. There are often other more valuable things you can be doing with your time, such as working on that side project, or…

3) Technical writing and blogging

Writing about what you know, whether it be a tutorial, a thought piece on a specific piece of technology, a guide or discussion, or even a unique piece of research is a fantastic way to demonstrate what you know, potentially what you’re working on, and where your passions lie. It’s also a neat way of building up your own personal network and gives you something to talk about in that important interview.

You could also live stream, podcast, or create a YouTube channel. Whatever medium and format suits your style of expressing yourself.

4) Making use of your university

University is an incredible resource for networking, for getting involved in research, and may even have teaching assistant or demonstrating opportunities for you to take hold of. Research and teaching are especially great to have on a resume, as they both demonstrate a great deal of competence in a certain area, such as in a programming language or field of computing.

It doesn’t all need to be computer science or programming related though. Look for opportunities to be involved in sports and clubs that interest you, or volunteering schemes where you can give back to the local community. Volunteering is especially useful at building soft skills employers are looking for, helps paints you as an empathetic and likeable person, and can even open more doors for paid employment. It happens!

One thing to note though, avoid letting your grades slip because of any of your extracurricular. It’s something I see quite frequently and would encourage people to find a balance as best as they can.

5) Classes and courses

Taking a class or free course in something different can broaden your horizons and help paint you as someone knowledgeable, has a keen desire for learning (which is something developers never stop doing!) and isn’t just someone interested in programming and nothing more.

Learning how to do 3D modelling, a foreign language, or a social science like psychology are all great examples of how you can further spread out your skillset. You can even do these online for free by undertaking a MOOC (massively open online course) on websites such as Coursera.

Alternatively, this is a great time to work through online curricula such as freeCodeCamp or The Odin Project to further bolster your portfolio. If boot campers are doing it, then find some free time to work through them too. They’re great for sharpening the technical skills that your coursework might overlook.

6) Internships and industrial year placements

University students who are looking to compete for the best jobs should look to carry out internships in the summer . There is no better experience than real-world experience, and subsequently, internships are worth their weight in gold. Whilst it’s great to get an internship at a major company, don’t overlook smaller organisations, as the experience is nevertheless a serious advantage and you can learn an incredible amount no matter where you go.

If your university programme or degree scheme offers the ability to take an industrial year placement or a “year out” to work in an extended internship placement (this is common in the UK) then you should seriously consider this. Almost every student I’ve spoken to who has taken such a year before their second and final years of study have attested to just how much they have learned within that year, and how it has recharged them to finish their course. Some high-flying students who impress their employers can even score graduate jobs.

The only exception to all of the above is unpaid internships. If you want to take one, don’t let me stop you, but I strongly believe that they are exploitative and that it’s bullsh*t to have someone live out of pocket just for the experience.

(It’s also not the same as contributing to FOSS or volunteering, which is something you do generally for a good cause or community.)

7) Casual employment

If you can’t secure an internship, please don’t turn your nose up at casual work over the summer, or even part-time whilst you study! Whether it’s teaching, cleaning, barkeeping, or stacking shelves, work experience is work experience and it helps you to develop soft skills and an all-important reference for later.

Again, don’t break your back by earning a paycheque when you should be studying. But I empathise that sometimes it’s necessary to stay financially afloat. Balance is key and hopefully, you can find it.

Conclusion

I hope that you found my advice helpful. It is important to note that this is not the end-all and be-all of all student advice and that there are likely to be important points that I missed, so definitely continue to read here on the Internet and further afield for even more valuable advice!

Fun with Clippy.js

by

Remember Clippy? The (not very) helpful assistant that was a major part of Microsoft Office for numerous years? Sure you do!

These interactive assistants were part of the Microsoft Agent suite of technologies and were incorporated into Windows XP as well. It was also infamously used in BonziBUDDY – the fun and interactive gorilla that also happened to be… spyware.

Whilst these technologies have been long mothballed in favour of more intelligent assistants like Siri and Cortana, Clippy and friends live on in our web browsers in the form of a fun jQuery library called Clippy.js.

Should I use it?

In a real-world project, probably not. It’s out-of-date and requires the use of jQuery. It also loads agent data and sounds across the Internet from an Amazon S3 store. But is it fun? Yes!

By the way, if you’re looking for ways to use Microsoft Agent in your .NET applications, you should look into DoubleAgent instead.

As far as I’m aware, there is a version that has been imported to vanilla JavaScript ES6, but I haven’t experimented with it so far.

Installing and embedding Clippy.js

You can clone or download Clippy.js from its GitHub repository, here. You’ll want to pull the minified JavaScript file and CSS stylesheet from the build directory.

As for jQuery, you can choose to download that also (from their website) but I recommend using their official CDN, or content delivery network. The current version at this time of writing is 3.5.1, and including the minified version reduces the amount of data needed to be downloaded by your web browser.

Don’t use out-of-date versions of jQuery unless you absolutely have to.

First, include the CSS stylesheet and necessary JavaScript files into the <head> tag of your webpage:

<head>

<!-- Include the Clippy.js stylesheet, assuming locally -->
<link rel="stylesheet" type="text/css" href="clippy.css" media="all">

<!-- jQuery -->
<script 
        src="https://code.jquery.com/jquery-3.5.1.min.js" 
        integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" 
        crossorigin="anonymous" 
        defer
></script>

<!-- Clippy.js, assuming locally -->
<script src="clippy.min.js" defer></script>

</head>

If you don’t include the defer attribute on your scripts, then you should insert them into the footer of the webpage to ensure that they only begin loading once your page has finished loading – it’s also important that you include Clippy.js after jQuery.

Usage

You can write your jQuery for playing with your agent in-line or in an external file, but for our examples, let’s keep everything within a <script> tag.

First, you should note that you have a choice of multiple agents that Clippy.js supports, including but not limited to:

  • Clippy – obviously
  • Peedy, the parrot
  • Rover, the dog from Windows XP
  • Bonzi, the purple gorilla

Let’s use Clippy and get it to appear.

<script>
  clippy.load('Clippy', function(agent) {
    agent.show();
    agent.speak('Hello World!');
  });
</script>

With any luck, it should appear and greet us! You can find a full list of available action actions from its aforementioned GitHub repository.

Building a very basic action generator

See the Pen Clippy.js by Oliver Earl (@oliverearl) on CodePen.

We’re going to build a very basic program that constructs an agent and has them go through each of their animations, one by one. You can follow along or take a look at the above CodePen. If it isn’t appearing for you, you can click here to get it.

Let’s add a heading and a paragraph element to our webpage. The paragraph will have an ID that we can target with jQuery later. You can use whatever CSS styling you want – I’ve just replaced the default text font with sans-serif for now.

<main>
  <h1>Current animation:</h1>
  <p id="state">None</p>
</main>

Let’s declare a new function that will take two parameters – an agent and the agent’s animations. I’m assuming absolute basic JavaScript knowledge, so I’ll keep things as simple as I can. Add this underneath the }); of the last block of code, but still before </script>.

In the block before it, let’s use the JavaScript function setTimeout() to call this new function after a few seconds have passed – we will pass our initialised agent and its available animations as arguments, and set a time of 8000 milliseconds – 8 seconds. It should look like this:

<script>
  clippy.load('Clippy', function(agent) {
    agent.show();
    agent.speak('Hello World!');

    setTimeout(animate(agent, agent.animations()), 8000);
  });

  function animate(agent, animations) {
    // Code will go here
  }
</script>

Let’s consider what we need to do by decomposing the problem, we want to:

  • Loop through all of the available animations
  • Have Clippy perform that animation
  • Print out what animation Clippy is performing to the paragraph tag.

In our new function, we can use a jQuery element selector to store our paragraph HTML element in a variable. jQuery variables are typically denoted by a $ sign. We can put this before our loop so that it doesn’t get redeclared on each iteration.

let $currentAnimation = $("#state");

Now let’s consider the loop. We can use a basic For loop to iterate through the animations, as we know exactly how many times we need to loop through (by measuring the length of animations). Within the loop, we can have Clippy perform said animation, and use jQuery to update our paragraph using its built-in text() function.

function animate(agent, animations) {
  let $currentAnimation = $("#state");

  for (let i = 0; i < animations.length; i++) {
    agent.play(animations[i];
    $currentAnimation.text(animations[i]);
  }
}

It looks good! But there’s a problem. Can you work out what it is?

Computers are fast, and Clippy.js uses a queue system to asynchronously perform animations, meaning that the text will update to the very last entry whilst Clippy performs each animation in its queue. We need to slow down this execution using the setTimeout() function that we used earlier:

function animate(agent, animations) {
  let $currentAnimation = $("#state");

  for (let i = 0; i < animations.length; i++) {
    setTimeout(function () {
      agent.play(animations[i]);
      $currentAnimation.text(animations[i]);
    }, i * 8000);
  }
}

Conclusion

And that’s it! I hope that you’ve had a little bit of fun with Clippy.js. Please feel free to fork the CodePen and build something uniquely your own. I hear other developers have managed to embed their own agents inside React or Electron apps, which is both impressive and uniquely horrifying.

Until next time!