Do you remember back in elementary school, where that one math-concept kept kicking your ass? Did you take algebra in college and spend hours reading the material, eyes glazed over? If so, you know what this week of Lambda was like.
This week, we dove into the intricacies of React. We covered tooling, lifecycles, and a whole bunch more. Also, I hate Higher-Order Components. That's all.
For those not in the know, I’m a student at Lambda School’s Full-Stack Web Development program (More here). Lambda School offers 9-month programs in web development, data science, and iOS development that are free until you get a job. If you don’t get a job, they don’t get paid.
I do a write-up every single week about my experiences. If you're not caught up just yet, you can start with Part One right here, or just keep reading!
If only it were that easy…
I think each and every student struggled with at least one topic/concept this week. Our intro to React in Week 6 was pretty easy, so people were generally pretty confident and easy-going on Monday morning. Boy, were we in for a surprise on Monday morning.
There is a lot to learn about React.
Day 1 was all about data-evaluation and using Prop-Types. This came pretty naturally to most of us as soon as we'd gotten the hang of the syntax. Quick question: who the hell thought it was okay to have three different ways of spelling PropTypes, depending on the context?
Then, it was onto Component lifecycles. That was a lot to take in but nothing mind-blowing. If you're not familiar with React, whenever a component gets changed and has to re-render, there are several phases it moves through. At every junction, you have the opportunity to perform certain tasks and mutate data. Think of it as a quick pitstop before moving onto the next phase. As a concept, it makes sense. Putting it in practice was a tad harder for some people. (Note: with the introduction of Hooks, the majority of lifecycle methods has become superfluous. Will have to look into this in my spare time)
Higher-Order Components were the bane of my existence this week. Since I was already familiar with the notion of Higher-Order Functions (i.e. passing a function as input to an encompassing function), the general concept made sense. For some reason though, I really struggled to get it working in my code. I hit some sort of mental block whenever I tried to move away from the more trivial use cases.
Luckily, the entire EU cohort really rallied together and helped each other whenever possible. Code-examples and online guides were passed around and one-on-one help was only a message away. In the end, most of us managed to get it working.
Some extra practice is definitely in (Higher) order, but it was a victory nonetheless.
Finally, we briefly covered styling in React. This could be an entire week worth of classes all by itself. I've always loved the simplicity of Styled Components. With component-specific style sheets, it often dissolves into a mess of classes and specificity-issues. Most students shared my enthusiasm and quickly got used to it.
One cool thing was that we spent four days working on the same project, an Instagram clone. We were supplied a dummy API-endpoint and some pointers on how to implement certain features. Other than that, we were on our own. The results were remarkable. But having a single project for an entire week of classes has its pros and cons.
It definitely helps with getting started on Days 2-4. You know the code, know how it works, and where to find what. It makes for a natural progression in learning, adding new features as you learn new techniques.
There are some downsides, though. There's no way to reset your work or to make sure your code follows best practices. Some students might not structure their code in a way that's conducive to future work. (Though I guess this is a good learning-point all by itself). A few students spent a couple of hours restructuring their entire code-base because of decisions they'd made on previous days. If that doesn't teach the value of writing easily-maintainable code, I don't know what will.
As most people are curious about the exact curriculum at Lambda, I’ve listed them all down here.
In Week 7 we covered:
As always, I tried to review some extra material. Mostly out of curiosity, but sometimes to understand concepts that didn't come through too well during classes:
I'm starting to notice that I prefer doing research on the side over doing stretch challenges as part of the curriculum. This might have something to do with seeking out things I'm more comfortable with. Whatever the case, I have a backlog of all stretch assignments I haven't done yet. I consider it a point of pride to finish all of them before graduation. No half-measures.
The entire class is starting to become comfortable with React. They're confident in being able to build simple apps and building them well. It's incredible how much can change in a month and half. Most of them had never written basic HTML before starting Lambda!
And we've only covered 1/4th of the curriculum…
When starting with Lambda, were you scared of it being a scam? What if it hadn't measured up to your expectations?
I was not too worried. I've followed the career of the CEO for a good five years of so. He's always seemed like a very genuine guy and I was confident in his ability to pull this off. The Income-Share Agreement is what convinced me to participate, though.
If it turned out to be a hoax, no harm done. After all, the conditions for the ISA wouldn't apply and I wouldn't have to pay a cent. Conversely, if they did a good enough job to satisfy the ISA-requirements, I'd be more than happy to pay the required 10%.
Have you experienced any issues as the first European cohort?
So far, there have been but a few. The European cohorts have their own support network of Project Managers and Instructors. We don't really interact with the US that much. One thing I've noticed is that the EU cohort tends to be a little isolated. Since our day of classes wraps up before the US-based class has even started, there's little overlap. As a whole, the EU cohort seems to be less active in the main chat on Slack.
Every so often, Lambda will host guest lectures or so-called brown-bags where experts dive into a subject of their choice. However, these are all timed to coincide with the US-schedule; i.e. at around 4AM European time. They get recorded and put on Youtube, but it's far from ideal.
Next week, we'll be going even deeper on React. Routing, Client-Side Rendering, HTTP and AJAX will form the majority of the material. We'll be covering some critical stuff, so I have to make sure I clear out enough time to revise and read up on stuff if need be. It'll be fine.
Finally, I'm really grateful for having had the opportunity to enroll in Lambda. Sometimes, it feels like I'm experiencing the future of education.
I sincerely hope you enjoyed this week’s overview .