study group

My podcast with Scott Hanselman

/ Daphne Chong / 4 Comments

Yes, that’s right – I recorded a podcast with Scott Hanselman 😀 There’s a story behind it too…

I bumped into Scott at NDC Sydney. It was the evening before the main conference started, and we were both helping out with the Kids Code Club. We started chatting about what I was presenting on Thursday – video transcoding systems, cloud services, various price points, why our new system was worth building.

Scott: “Hey, would you like to do a podcast? It’s just a really casual chat, just like this.”
Me: “Sure! Sounds good.”

Just to make sure I was prepared, I wrote some notes about video transcoding, AWS services, and reviewed bits we’d built in our system. A couple of weeks later, we caught up via Skype:

Scott: “Great, thanks for doing this! It’s usually best to talk about something you’re really passionate about. What would that be?”
Me: “Um…” thinking: video transcoding is pretty awesome, but it’s not my #1 super-fun-happy-thing. But now I have to come up with thirty minutes of content I haven’t prepared…

I’m not really good at impromptu. That’s why formats like my blog (where I can draft things), and public talks (where I can prepare), work okay for me. So doing a thirty minute discussion flying blind was a terrifying prospect.

However, Scott was really, really supportive. After some back and forth, we came up with a blend of topics that include continuous learning, becoming more social, finding your tribe, and making it work for you. You can listen to the podcast here.

I’ve got a healthy respect for Scott’s work now that I’ve seen how much time, effort and support he puts in to the things he does.

If you haven’t heard Hanselminutes before, give it a try. There’s some great slices of developer life in there. And now I’m one of them. 🙂

 

Review of Coursera’s Algorithms Part I by Princeton

/ Daphne Chong / 1 Comment

This is the first in a series of two posts about a study group I organised for learning Algorithms & Data Structures. This post focuses on the content of the course, which is Princeton’s Algorithms I on Coursera.

The course covers a variety of data structures and searching and sorting algorithms from a programmatic implementation angle (as opposed to mathematic proofs; more on that in my second post). Specifically, this one covered union-find, binary search, stacks, queues, insertion sort, mergesort, quicksort, binary heaps, binary search trees and red-black trees, and a lot more.

The course has multiple types of content to help you learn:

  • The major component is the video lectures, which form about 2.5 hours of content each week and present some algorithm theory
  • Detailed lecture slides
  • Exercise questions, which test you understand that theory
  • Assignments, which make you put an implementation of an algorithm in practice
  • Final exam (I haven’t done this yet, but I still have a few weeks.)

Officially, the course is 6 weeks long, and requires 6-12 hours a week of effort. I think most people in our group underestimated how much time this really takes from your life.

Good things about this course

The combination of lectures, exercises and assignments was a really good way to cover the material from different angles. If you appreciate structured approaches to learning, this will tick all the boxes.

Videos: All of the material is professionally shot and edited. The entire series is presented by Robert Sedgwick, who is a very good lecturer. There is a good level of detail and explanation for each algorithm, especially the animated walk-throughs of each sorting algorithm. You have the option of watching the videos at a faster speed on the Coursera website, and I chose to watch it at 1.25x most of the time, as Sedgwick speaks quite methodically but slower than I am used to. (If you download the videos, you can’t take advantage of this feature, and you also miss the interim quizzes in the videos). It’s very helpful watching videos instead of listening to a live person, as you can pause them and rewind whenever you need to.

Slides: The slides are great. Very detailed, well-laid out and with diagrams to illustrate various concepts. The only thing missing from the slides were the animated walk-throughs of how each algorithm works, but you can always re-watch the videos.

Interim quiz: at the end of each video, and sometimes in the middle, you have to answer a question about the content you just watched.

Discussion boards: The Coursera site includes discussion boards where you can post questions. They’re monitored by people at Princeton who are helping to run the course. It’s a great resource when you get stuck.

Auto-marking for assignments: Assignments are all auto-marked for each submission, and the results from marking are really detailed. Each submission is run though lots of tests, and it also analyses your usage of memory & time relative to input (i.e. are you using constant, logarithmic, linear, quadratic time, etc). I found this quite valuable.

Real-world examples: Discussions of practical implementations of algorithms, such as a physics engine for particles, or easily finding whether lines/objects intersect, were really interesting.

Credibility: Sedgwick is a professor at Princeton’s school of Computing Science. You’re hearing from one of the people who has spent a lot of their life studying and working with algorithms – he’s written several books on algorithms, one of which is used as a reference for the Coursera course (the content is available for free on a corresponding book site). He also found a more efficient variant of Red-Black Trees in 2007, which he discusses in the lectures.

Choose your level of participation: You can cut out various parts of the course if you prefer – for example, if you were to only watch the lectures and make your own notes, you could spend 3 hours a week doing this course and still get something out of it. The minimum I’d recommend is watching the lectures and doing the exercises, as the exercises force you to step through the algorithms and work out what they’re doing.

Language-independent: It’s possible to complete these assignments in different langauges, as our study group proved. We had people write solutions in Rust, Python, Golang, C# and Scala. However, the majority of them completed in Java to take advantage of the auto-marker for the assignments.

Things I’d change about this course

Assignments not geared for unit testing: The APIs for the assignments were quite strict – it was almost impossible to test using dependency injection, or trying to refactor one giant (public) method into smaller public methods so you could test them independently. I did write some tests, but I also ended up submitting assignments to the auto-marker to get feedback for some aspects. I’d prefer if the API was less strict so that you can package your own classes, and break things into smaller chunks.

The assignments vary in complexity. Some require only 2 or 3 hours; others could take another 10 hours just by themselves.

Course schedule: The start date and schedule of the course is advertised as fixed, and quite intense. When they say you need 6-12 hours, they do mean it (and more). In reality, all assignments and lectures have “hard” and “soft” deadlines, and can be submitted up to 6 weeks after the lecture is released.  If we had known, we would have built some catch-up weeks into our study group dates to allow people to keep pace. This isn’t Cousera’s fault, but some knowledge that the content would be around for ~3 months would have helped plan a better schedule for our study group.

Some content not as relevant: This is a personal preference, but the course covers a lot of different searching and sorting algorithms in depth; in reality only a handful of them are in use by major languages. I’d prefer to concentrate on the ones in use, and not cover the ones that have been superseded.

Summary

The course was intense, but I learned a lot and it helped connect some dots on how to solve particular types of problems. For me, the best moment was an email from Aidan, one of our study group members, in the last week:

I actually used a weighted quick-union at work yesterday! I‘m as shocked as everyone else.

Proof that it is actually relevant 🙂

As for Algorithms Part II, I’m sadly stretched working on various things in life, including this blog, Women Who Code Sydney and organising a variety of things with my work at the ABC.  However, Caspar Kreiger is continuing the second half starting this week, so get in touch if you’re interested!  I plan to pick up Part II in October when it is run again.

Study Group: Algorithms & Data Structures

/ Daphne Chong / Leave a comment

Since doing a Javascript study group last year, I’ve been keen to organise a Data Structures & Algorithms study group (partly to brush up on interviewing).

I’m pleased to announce that the study group will start January 28th. If you’re interested and live in Sydney, read on.

What will I learn?

We will be doing the Algorithms I course by Princeton university.

It involves a series of lectures & quizzes you watch at home, followed by a group meeting every Wednesday. At the group meeting you can ask questions about anything you didn’t understand, and start to go through coding exercises.

The course material is presented in Java, however you can choose a language of your choice to complete the problems. If you would like Coursera to mark your assignments and final exam, you would need to complete the course in Java. (Note: Completion certificates aren’t issued for this course.)

If you are unsure of Java syntax, please read up on a quick syntax guide before starting the course.

Where and when do we meet?

Atlassian has kindly agreed to host our meetings. Their office is Level 6, 341 George Street Sydney. The building entrance is off Wynyard St.

We’ll meet on Wednesdays at 6:30pm (please be prompt).

The course is 6 weeks and runs from January 28th until March 4th. There will be an optional week after the course ends to practice answering technical interview questions.

How much will it cost?

The course is free if you attend 5 out of the 6 meetings. You can skip one meeting without a penalty.

Everyone will be asked to pay 6 x $10 per meeting at the first meeting, a total of $60. For every meeting you attend, you’ll be credited $10 back.

For anyone who misses a meeting, their money goes into a pot. At the end of the course, the pot will be divided among the people who attended the most meetings. Nerdery pays 🙂

This is mainly an attempt to identify the people who really want to participate, and to motivate people to stick with the group.

Prerequisites

This is not a beginner’s course. You should:

  • Be able to code confidently in a language of your choice
  • Be comfortable with git
  • Understand the concept of a class, objects, functions, arrays, lists, sets, loops, recursion and the core types available in your chosen language
  • Understand what unit testing is
  • Be willing to discuss your approaches to problems, and demo code
  • Be willing to spend 4-12 hours a week watching lectures and completing code assignments

I’m not teaching this content, I want to learn it and would like other motivated people around at the same time.

How can I sign up?

The study group will be limited to 15 people. The first 15 people who contact me (@daphnechong) and bring a refundable $60 to the first meeting will be eligible.

See you there 🙂

Code Sydney – a Javascript study group

/ Daphne Chong / 1 Comment

I’ve done quite a few random side projects using Javascript, but I’ve never learned it “properly”, and I’ve always wanted to. In a nice coincidence, a fellow geek Lucy Bain started a Javascript study group a couple of months ago called Code Sydney, which uses the Odin Project‘s course material – so of course I signed up.

Course Content

I’ve really been enjoying the course so far.  It doesn’t assume previous knowledge about Javascript, so it starts with the basics – variables, functions and jQuery. It then progresses through objects & prototypes, the DOM, events, callbacks, scope, closures, and popular frameworks like jQuery, Angular and Node.

Every week  you have to do some homework reading about a specific topic, e.g. prototypes.  There will also be an accompanying coding project to build, which uses the knowledge you’ve just read about. We start the coding project as a group during the study group meeting, and complete it at home later during the week.  Nobody is teaching the material for the study group, so it’s up to each participant to do their homework.

My contributions so far are on github as source code and demos (disclaimer: there is almost zero CSS effort put into these). The more fun projects so far have been rebuilding games, including snake and tic tac toe.

Format

We meet in the Atlassian office once a week for around 2.5 hours.  There are 2 or 3 tutors each week who’ve generously volunteered their time to help out, answer questions and review code.

The format of each night is roughly:

  • Check in (5 mins). Attendance is recorded as a motivational factor.
  • Demos (15-20 mins). A few people demo their solutions to the previous week’s project, and people can discuss different approaches.
  • Questions & Suggestions (5-10 mins). People have a chance to bring up any additional questions for the tutors, or the tutors can suggest “best practice” recommendations after the demos.
  • Start practical coding problem (up to 2 hours). We start the week’s coding problem in class, and finish the rest of it at home. If you aren’t sure how to approach something, you can ask a tutor.

Things I love about the study group model

  • There’s a set time and place to focus on learning something new, so there’s a natural deadline for you to achieve something by
  • I’ve learned much more than if I tried to do the course by myself
  • I’m seeing progress and building on my knowledge each week, which is rewarding and motivating
  • I’ve met new people
  • I get the chance to ask experienced people questions if I’m unsure about something
  • I’m building up a portfolio of fun projects (minesweeper this week!)
  • It’s much cheaper, and arguably better quality than an official course run by someone getting paid to teach. We discuss a lot of our solutions and get to see the merits of different approaches.
  • Nothing stops you paying it forward – feel free to organise your own study group, using the same material. All you need is a space to meet up.

I’m so excited about the format that I’m thinking about co-starting one for algorithms & data structures, as I’ve wanted a refresher and the ability to think/learn about them in a non-pressured environment. Part of the challenge is finding existing people who are knowledgable and enthusiastic about the subject to be tutors, or whether to run it without tutors. In any case, watch this space 🙂