<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[About Codecademy - Medium]]></title>
        <description><![CDATA[Lessons learned while teaching the world to code - Medium]]></description>
        <link>https://medium.com/about-codecademy?source=rss----396b101c94---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>About Codecademy - Medium</title>
            <link>https://medium.com/about-codecademy?source=rss----396b101c94---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 02:00:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/about-codecademy" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Codecademy’s Quest to Connect Learners to Economic Opportunity]]></title>
            <link>https://medium.com/about-codecademy/codecademys-quest-to-connect-learners-to-economic-opportunity-71a194206a8d?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/71a194206a8d</guid>
            <dc:creator><![CDATA[zach sims]]></dc:creator>
            <pubDate>Tue, 23 Feb 2021 16:33:11 GMT</pubDate>
            <atom:updated>2021-02-23T16:33:11.122Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MSEdLMmlYdOoCT6VMXqigQ.png" /></figure><p>Today, we <a href="https://news.codecademy.com/40m-series-d-codecademy/?utm_source=external_blog&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">announced</a> Codecademy’s Series D financing. To think about where we’re going, it’s important to remember how we got here in the first place. Codecademy started after realizing the tremendous gap between education and employment. The very same societal problems we set out to solve have been exacerbated further since:</p><ul><li>The cost of higher education has increased at a marked rate and, with it, so too has the student debt crisis, while traditional education rarely leads to the right job outcome</li><li>The profile of the average student has changed, and many are now adults and in the workforce, unable to take full-time classes the same way they once used to</li><li>The technical skills required for jobs today change faster than ever before</li></ul><p>In 2011, we saw these trends and launched <a href="https://www.codecademy.com/?utm_source=external_blog&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">Codecademy</a>, our effort to build the easiest way to learn to code. We built a simple product, one that was built on providing an engaging, interactive, learn-by-doing focused experience to teach programming in a way that was flexible (so learners could learn anywhere and anytime) and accessible (low cost or free). After launch, tens of millions of people around the world used Codecademy to start their journey learning to code.</p><p>Our secret master plan in 2011 was:</p><ol><li><strong>Help learners get the skills they need to find jobs and upgrade their careers</strong></li><li><strong>Help companies stay relevant by equipping their employees with digital skills</strong></li><li><strong>Build a platform to connect consumers and companies to each other and new opportunities based on those skills</strong></li></ol><p><em>Our Learners</em></p><p>We’ve been quietly executing on that vision ever since. Much of our story remains centered around individual learners — at this point, more than 50 million of them around the world have taken courses on Codecademy. They include people like Aabhusan, who learned to code this past year with Codecademy and then <a href="https://www.codecademy.com/learner-stories/software-engineering/6SmSmZbzwt8kiFykwBrQ40?utm_source=medium&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">built a website in his home country of Nepal</a> to help his fellow citizens learn more about COVID. Among them are also people like Kate, a stay-at-home mom for over 15 years who learned to code in her free time and secured a full-time job as a developer to become the sole provider for her family after her husband lost his job. Times like these remind us that what we’re doing matters: hundreds of thousands of people around the world use Codecademy every single day to learn the skills they need to find jobs, upgrade their careers, and live better lives.</p><p>We launched Codecademy Pro in 2016 to help our learners get to their goals even faster. With a focus on Career Upskillers (people learning skills to perform better in their existing jobs) and Career Switchers (those becoming full-time developers), we rolled out a ton of new, advanced curriculum and Career Paths to help our learners become Data Scientists, Engineers, or to use their skills in every field that technology has permeated (which, at this point, is everything!). We built exclusive community features and certifications to help our learners demonstrate their knowledge to future employers.</p><p>We built Pro not just to help subscribers, but also to help our learners in need. In 2020, in the midst of the COVID pandemic, we gave <a href="https://news.codecademy.com/100k-student-scholarships/?utm_source=external_blog&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">100,000 subscriptions to K-12 learners</a> in need while they were out of school, and another <a href="https://news.codecademy.com/100k-accounts-to-workers-in-need/?utm_source=external_blog&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">100,000 subscriptions</a> to people who were out of work or furloughed as a result of the pandemic, underlying our belief that we can do well by doing good as well.</p><p><em>Our Company Partners</em></p><p>Late last year, we launched Codecademy for Teams and embarked on the second part of our vision. After hearing repeatedly from our learners that they took Codecademy into their workplace to deploy their skills and upskill their coworkers, we built something specifically for them. Now, teams at hundreds of companies around the world use Codecademy to make sure they’re on the cutting edge of technology instead of getting cut out of it.</p><p><em>Our Future</em></p><p>While we’ve been around for ten years, we believe the problem we’re solving is a generational one and that we’re just getting started. We’re still building a world where anyone can access economic opportunity and all it takes is an internet connection and the drive to learn. We raised $40m on the success of Codecademy Pro and Codecademy for Teams to bring our vision to fruition. Our focuses remain the same:</p><p>1. <strong>Help learners get the skills they need to find jobs and upgrade their careers</strong>: with Codecademy Pro, we serve more than 150,000 paying subscribers a month and millions of free learners. But we’re just getting started. Over the next couple of years, you’ll see us:</p><ul><li><em>Teach more skills:</em> our name may be Codecademy, but we want to teach you <em>any</em> digital skill that can help you find a job. Programming and Data Science are just the beginning.</li><li><em>Serve the world:</em> while our learner base today is majority-US, we know that the future isn’t. We’re excited to work with our learners in other countries to build for them and for the learners of the future, who almost certainly won’t look like the software developers of the past.</li><li><em>Pioneer new ways of teaching:</em> when we first launched Codecademy, teaching with an in-browser development environment was new. We think Zoom isn’t the future of learning. Instead, we’ll bring you learning that adapts to you, is interactive and fun, and is with you wherever you are.</li></ul><p>2. <strong>Help companies stay relevant by equipping their employees with digital skills:</strong> Codecademy for Teams is just scratching the surface of how we can help companies. Already, we’ve seen everyone from Fortune 500s to small businesses use Codecademy to help onboard new team members, upskill existing ones, and build amazing career mobility inside their companies. Teams is only our first foray into helping companies: we know that creating better places to work and more efficient companies will help to build a more technology-oriented and efficient world.</p><p>3. <strong>Build a platform to connect consumers and companies to each other and new opportunities based on those skills:</strong> join us to help build the next phase of Codecademy. With more than 50 million consumer learners and hundreds of companies as clients, we have the making of a two-sided marketplace to help them find everything from employment to the next API to use.</p><p>At Codecademy, we’ve never been a team to think small. When we started the company, investors around the world told us that building a large company in education was hard. Nearly a decade later, we’re still here and proving them wrong, with a company that’s growing quickly and sustainably (we’re cash flow positive!) and, most importantly, helping millions of learners around the world. Our new financing helps us double down in all these areas and more to bring economic opportunity to untold millions more around the world. If you’re looking to level up in your career, I hope you’ll give us a chance. And if you want to have a greater impact on the world around you, <a href="https://www.codecademy.com/about/careers?utm_source=external_blog&amp;utm_medium=medium&amp;utm_campaign=series-d&amp;utm_content=series_d_medium">come join our team!</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71a194206a8d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/codecademys-quest-to-connect-learners-to-economic-opportunity-71a194206a8d">Codecademy’s Quest to Connect Learners to Economic Opportunity</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Keep your Large Redux Application In Check with Redux-Usage-Report]]></title>
            <link>https://medium.com/about-codecademy/keep-your-large-redux-application-in-check-with-redux-usage-report-e2e4f31bb86f?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/e2e4f31bb86f</guid>
            <category><![CDATA[devtools]]></category>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Alex]]></dc:creator>
            <pubDate>Tue, 06 Feb 2018 14:23:56 GMT</pubDate>
            <atom:updated>2018-02-06T14:29:23.649Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*_ynPGSWJ3dcoR9zF3vh4kg.png" /></figure><p>One of the refreshing things about moving to Redux from other types of state management is how easy it becomes to understand what’s going on in your app. You can use Redux Devtools to get a complete picture of the current state, and trace the series of actions that got it there. It’s all in one place, in a single object tree. Everything seems so much more transparent than before.</p><p>As your app grows, however, and multiple developers work on features that add more and more data to the store, things can start to get foggy again. Maybe some data is being passed down from the server, but no longer actually used, bloating the store. Or maybe the entities aren’t fully normalized, leading to confusing duplication. Sometimes, it’s simply difficult to discern which components are accessing which parts of the store, or to get a clear sense of how data is flowing through the app.</p><p>Codecademy was an early adopter of Redux and, as our app has matured, we’ve dealt with some of these problems. Recently, as I was refactoring part of our store, I started wishing for a tool that would tell me exactly which parts of the Redux store were being used in any given view, and which parts of the store remained completely untouched by the app. Ideally, I also wanted a way to pause code execution when certain parts of the store were accessed, so I could see exactly how our React component tree related to the Redux state tree.</p><p>I looked around for such a tool, but my search came up empty. So I decided to build it myself — a store enhancer that outputs a report of your Redux usage, aptly named <a href="https://www.npmjs.com/package/redux-usage-report">redux-usage-report</a>.</p><p>Let’s look at how you might use it to audit your Redux store.</p><p><strong>Practical Guide to using Redux-usage-report</strong></p><p>Here’s an example based on a time I wanted to investigate whether the data being passed down from the server in a certain courseProgresses entity was actually used in a particular view of our app.</p><p><strong>1. Add the store enhancer</strong></p><p>Install the redux-usage-report package and add the store enhancer <a href="https://github.com/aholachek/redux-usage-report#1-redux-store-usage-tracker-generatereduxreport">according to the instructions</a>.</p><p><strong>2. Generate the report</strong></p><p>Load the app, perform any user interactions you want to register, and then call reduxReport.generate() in the browser console.</p><p><strong>3. Inspect the </strong><strong>unused part of the report</strong></p><p>The unused object returned by the report shows which parts of the store were never accessed. (All screenshots are from the Chrome devtools).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rrXYVZQnTwPtk11G." /></figure><p>Here, for instance, I see that quite a lot of the courseProgresses data wasn’t needed to render the current view of a course listing page. (If a key is null, that means everything underneath it was not accessed.) It seems that I might want to investigate whether some of the data might be redundant for rendering the current view.</p><p><strong>4. Inspect the </strong><strong>used part of the report</strong></p><p>But which parts of the courseProgresses entities were actually required to render the current view? To answer that question, I can inspect the used key of the report to see which parts of the store were accessed at least once:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KHwqSYfF79ZxToGM." /></figure><p>It seems clear enough that, for the courses that were actually rendered for this page, the only parts of the courseProgresses entity accessed were the started key, and, if that was true rather than false, the percent_complete key as well.</p><p><strong>5. Set a breakpoint</strong></p><p>Say I want to see exactly when the started key is accessed. To do this I can type the following in the console:</p><pre>reduxReport.setBreakpoint(&#39;entities.courseProgresses.bySlug.react-101.percent_complete&#39;)</pre><p>After I reload the page, execution will be paused when that value is accessed, and I’ll be able to go down the call stack and see where it’s used.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sXB3hrGt-rAroC8I." /></figure><p>Here, I see that the percent_complete object is passed to the TrackedCourseCard component as a prop called progress.</p><p><strong>How it works</strong></p><p>Since state in a Redux store is an object, I had to figure out how to augment a JavaScript object to track which parts of it were accessed, and provide a<em> diff</em> of the used and unused parts on demand.</p><p>Luckily, ES2015 offers a convenient new API for adding custom functionality to JavaScript objects: Proxies.</p><p><strong>Quick Proxy Interlude</strong></p><p>To quote <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy">MDN’s proxy page</a>,“The <strong>Proxy</strong> object is used to define custom behavior for fundamental operations (e.g. property lookup, assignment, enumeration, function invocation, etc).” Here’s a brief code snippet demonstrating how a very basic proxy works. This one just logs any usage of an object to the console.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/61dec6489f28d3cb6db84c255fee1715/href">https://medium.com/media/61dec6489f28d3cb6db84c255fee1715/href</a></iframe><p>Redux-usage-report uses proxies, along with some extra code to keep track of what has been accessed. If you’d like to take a look at the full implementation of the library, you can <a href="https://github.com/aholachek/redux-usage-report/tree/master/src">check it out here</a>.</p><p>That’s about all there is to using redux-usage-report. It might be overkill to use it on a small Redux project or one with few developers, but if you are loading a lot of data into your app up front, or if you have a large store and want a better idea of which parts of it are accessed when, give it a try!</p><p>Want to learn more about how we use Redux at Codecademy? Check out my colleague Jon Samp’s <a href="https://medium.com/about-codecademy/react-router-to-redux-first-router-2fea05c4c2b7">article on making the switch to Redux-First-Router</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2e4f31bb86f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/keep-your-large-redux-application-in-check-with-redux-usage-report-e2e4f31bb86f">Keep your Large Redux Application In Check with Redux-Usage-Report</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TEACHING TWO WAYS]]></title>
            <link>https://medium.com/about-codecademy/teaching-two-ways-c0f058994459?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/c0f058994459</guid>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[teaching]]></category>
            <dc:creator><![CDATA[Jack Ratner]]></dc:creator>
            <pubDate>Thu, 30 Nov 2017 16:12:09 GMT</pubDate>
            <atom:updated>2017-11-30T18:34:18.032Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YEqNvcN_AlO3qG6DOOCtZA.jpeg" /></figure><p>I write code at Codecademy. So, in a sense, you could say I teach here. I think you could say that any of the 60 people on the Codecademy team teach our tens of millions of users to code. It’s Codecademy’s scale that unlocks a 500K student to one ratio.</p><p>Scale is essential to Codecademy’s mission. Our fully-automated interactive learning environment has allowed us (a company of roughly 50 employees) to teach tens of millions of people to code over the past six years. We’ve been able to keep prices accessible and offer courses for free.</p><p>Part of building our scaled education platform has meant focusing on those who are ready to learn, what they want to know, and then providing it to them. But what about people that aren’t passively searching the internet about learning to code — those that think they’d never want to work in an office or think that they could never swing it? With some students, particularly those coming from a variety of less-privileged backgrounds than my own, it takes more than putting a great website out there to demonstrate that there is a place from them in the tech world.</p><p>At Codecademy, we care about these people too, which is why some of my teammates and I volunteer with ScriptEd. We want to help students at under-resourced schools build coding skills, self-confidence in those skills, and increase their job awareness, so they see a brighter future of economic opportunity.</p><h3>Volunteering at ScriptEd</h3><p><a href="https://scripted.org/">ScriptEd</a> equips students in under-resourced schools with fundamental coding skills and professional experiences that create access to careers in tech. This is done through in-school programming, field trips, and internships that expose students to software development careers. Eighty-one percent of students are on free or reduced-price lunch, and ScriptEd also works to increase diversity in the engineering community with a student makeup that’s 46% Latinx and 36% black reports the Scripted website.</p><p>I volunteer for the the front-end web programming course that teaches HTML, CSS, JavaScript, and developer tools, like IDEs and GitHub. By the end of the students’ first school year, they will be able to create interactive websites.</p><p>At ScriptEd, I have the opportunity to contribute on a more personal level. My students tell me about their lives. They get excited and compete for my attention to show off a Spongebob GIF they have added to their website. They make fun of my mustache and my hair. And I stay with that same group of 25 students until they finish the year in June. No 10x, no scale.</p><p>But here’s where teaching at ScriptEd truly differs from Codecademy. In my day job, I serve students that know they want to learn to code. These students see themselves in tech and fitting into the community. At ScriptEd, students can be skeptical and reluctant to participate. They likely wouldn’t have benefited from Codecademy on their own no matter how well optimized our learning environment becomes. But what we can’t do from a distance, I like to try my best to in-person.</p><p>Earlier this month, one of my students, let’s call her Deidra, entered the classroom completely disinterested. She spent most of the warm-up activity chatting with her friend about how they would rather be somewhere else. I identified with Deidra; I was required to attend classes I thought I had no interest in, too.</p><p>The day’s activity was to create a webpage as an invitation to a party. It asked students to develop a theme, create a webpage with images, headers, paragraphs, and, finally, to use their newly learned capabilities with ids and classes to style parts of their webpage. Deidra reluctantly began work on the activity. She found one image and made a header on the page, but promptly drifted off into YouTube. This is the moment when an actual person can step in and where a web page lets you bounce.</p><p>I came over and asked her the theme of her party. Deidra said it was a “winter bash.” I asked what other image she might want for an invitation. She said she wanted snowflakes, but as a background for the entire invitation. We hadn’t yet taught background-image or positioning, but I saw her motivation — snowflakes. We proceeded to use CSS positioning properties, sizing properties, and z-index to see how an image in HTML can be manipulated to cover the background.</p><p>Sitting down with Deidra took a good amount of our time and produced a lot of “You mean we have to do more?” from Deidra. But, at the end of class, she had an invitation with an image of snowflakes. As she left class, she said, “That was hard!” with a big grin, excited to pick up where she left off tomorrow.</p><p>Being there in the classroom with Deidra, I was able to take what motivated her and use it to show her how she can use coding to achieve her interests. Since that day, Deidra brings her own initiative to assignments. She doesn’t seem too bored to complete her work. Moments like this happen almost every class. Each time a student is empowered to turn their creative ideas into reality via coding, they believe a little more in their potential as a coder.</p><h3>ScriptEd Field Trips</h3><p>At Codecademy, we also open our door to ScriptEd field trips. Last spring, I brought my ScriptEd class to Codecademy for a tour, lunch, and a panel with some of the team.We had a number of different roles and careers represented: software engineer, designer, product manager, curriculum developer.The students met the people who built a product they’d been using in the classroom. The panelists met some real-world learners.</p><p>In our hour-long session, the students learned a little more about the career opportunities open to them in the world, and the panelists learned a little more about what some of our users want to see on our platform.</p><p>Bringing ScriptEd students into the office for internships and field trips has inspired other co-workers to get involved as well. This year, Alex, a Codecademy Curriculum Developer, has joined me in teaching at ScriptEd. Like me, he keeps these students in mind as he helps create our upcoming courses.</p><p>But, most importantly, the field trip shared a world of opportunities that many of the students were unaware of. In bringing my classes to the office, I hope they saw that working as a coder is far from the classic IT basement myth. The software engineers and various product team members at Codecademy are a dynamic assortment of people with a variety of skills and backgrounds. By seeing this IRL, ScriptEd students get a chance to see how they could be part of a similar working environment.</p><h3>Internships</h3><p>This past summer, New York City companies hired 49 ScriptEd interns. Codecademy invited Xhesika and Samuel to revamp our team’s deployment dashboard. Doing so required learning JavaScript technologies like <a href="https://www.codecademy.com/learn/introduction-to-javascript">ES6</a> and <a href="https://www.codecademy.com/learn/react-101">ReactJS</a> and working through our <a href="https://www.codecademy.com/pro/intensive/build-frontend-web-apps-from-scratch">Build Front-End Web Apps intensive</a>. We also tried to share a variety of perspectives on life in the coding world by inviting them to daily standups, on coffee trips with employees across the career spectrum, and eating lunch together.</p><p>One day, a few team members who majored in computer science had a group discussion with Xhesika and Samuel. They had all kinds of questions for us, like what classes we liked and what subjects are relevant in our day to day as software engineers.</p><p>After her internship finished, Xhesika said, “I used this internship as a way to see if I should major in Computer Science in college or go another route, and I have decided I will major in it!” Samuel also decided to pursue computer science in college after the internship. Knowing that their time with us reinforced their confidence in such a major life choice made all the time and effort we put in worth it to me.</p><p>This is why working with ScriptEd is so important to me. I’m able to extend the scale of Codecademy by showing those that don’t see a future for themselves in coding that the opportunity is there for them.</p><h3>It’s the Mission</h3><p>We at Codecademy teach people the skills they need to find jobs. We care about teaching people and recognize the value of the many ways in which our team members get involved in teaching outside the office. While we work hard at making this mission accessible to all, we understand that this doesn’t reach everyone. Which is why my teammates are excited when ScriptEd students show up at the office. We learn a little more about those just outside our reach, and continue to grow our platform to be a resource learners of all kinds and backgrounds.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0f058994459" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/teaching-two-ways-c0f058994459">TEACHING TWO WAYS</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Animations in React From Scratch]]></title>
            <link>https://medium.com/about-codecademy/building-animations-in-react-from-scratch-c66a582c9b65?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/c66a582c9b65</guid>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Alex]]></dc:creator>
            <pubDate>Thu, 02 Nov 2017 19:14:22 GMT</pubDate>
            <atom:updated>2017-11-02T15:05:04.520Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/620/0*lOQ8olgJdn4v9NQ6." /><figcaption>Transitioning element positions in ComponentDidUpdate</figcaption></figure><p>Recently I was talking with a designer on my team about her vision for a redesign of a certain part of the <a href="https://www.codecademy.com/">Codecademy site</a>. She demoed some very sleek, somewhat elaborate transitions she had been exploring. I immediately started wondering how complex they’d be to implement in our app, which is built in React. Would I have to load in multiple new libraries? Was it even possible in React to do some of the seamless, sequenced animations of elements from one state to another that she was envisioning, without requiring incredibly complex code or awkward hacks?</p><p>Most of the time, when you want an animation in your React app, it makes sense to reach for one of the many libraries that abstract away the details and let you use a declarative style. But sometimes those libraries don’t get you all the way there.</p><p>Maybe you (or the designer you work with) envision a complex series of sequenced animations of multiple elements when a parent component enters and exits the DOM. Maybe you want to animate positions of certain elements as they are re-rendered in different parts of the app. Or maybe you want to take control over the transitions of a continually updating list, a la d3’s enter/update/exit sequence.</p><p>It turns out to be surprisingly feasible to create more complex animation effects in your own code without having to contend with the possible limitations of a React-friendly animation library. You will, however, have to be ok with going slightly against the grain of React. In the examples below, we’ll hook into lifecycle events, making components “impure” by occasionally delaying updates in order to animate elements from one state to another. We’ll also be reaching into the DOM directly using refs.</p><h3>Manipulating the component lifecycle</h3><p>To create certain types of animations, we’ll need to interfere with different parts of the component lifecycle. If we want to animate the removal of elements, for instance, we’ll need a way to delay the removal of nodes from the DOM for the duration of the exit animation. To animate element transitions from point A to point B across the screen, we’ll need to calculate node beginning and ending positions right before the browser paints the change to the screen, and manage layout transitions ourselves.</p><p>Luckily, React offers a variety of lifecycle methods that we can hook into. The method shouldComponentUpdate, which fires when a component receives new props or state, allows us to delay DOM updates until after an exit animation has finished running. If on the other hand we plan to transition elements from one part of the screen to another, we’ll need a way to record the previous positions of the elements right before they are updated. We can use two methods — either componentWillReceiveProps or shouldComponentUpdate to record the previous positions of elements, and then componentDidUpdate to reposition them and smoothly transition them to their new places.</p><h3>Accessing DOM nodes with refs and data-attributes</h3><p>We’ll use a <a href="https://reactjs.org/docs/refs-and-the-dom.html">ref</a> on the parent container to access DOM nodes so that we can animate them. Even though in the examples below the goal is to keep the animation logic and the components fairly decoupled, there are a few caveats.</p><p>First, the wrapped container component must be class-based rather than a functional component, so that we can access its DOM element via a ref. Second, some animations will also require each child to have a unique data-* attribute. (I’ll use data-id.) This attribute will help our animation function distinguish between the children elements and process them correctly.</p><p><strong>Separating animation concerns into a higher order component</strong></p><p>In the examples I’ve used<a href="https://reactjs.org/docs/higher-order-components.html"> higher order components</a> to separate lifecycle animation logic from the presentational logic of components. This is just one possible way of organizing things, and it<a href="https://reactjs.org/docs/higher-order-components.html#refs-arent-passed-through"> adds a bit of complexity when it comes to refs</a>. However, the pattern I’ve used in the examples seems to work fairly well.</p><p>It consists of three parts:</p><ul><li><strong>The presentational components</strong>, here a List and an Item component. They are mostly unaware of the animations, except for two things — as mentioned above the parent List has a ref, so it can’t be functional, and the child Item needs to render a data-id attribute.</li><li><strong>The animation functions</strong> in their own file. I’m using my favorite vanilla JS animation library,<a href="https://github.com/juliangarnier/anime"> anime.js</a> for the actual DOM manipulation. But you could use another JS animation library or CSS transitions and animations.</li><li><strong>The higher order component </strong>that wraps the parent List component and is passed the animation functions. At various parts in the component lifecycle, it calls the appropriate animation function with a ref to the wrapped List component.</li></ul><p>That’s a high-level overview of how the code is structured. Now, let’s look at the examples!</p><h3>One: A basic enter/exit animation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*DdqlGEUupD1i07czqsxGBA.gif" /></figure><p><a href="http://alex.holachek.com/react-animations-from-scratch/?selectedKind=Animation%20Examples&amp;selectedStory=1.%20The%20basic%20technique&amp;full=0&amp;down=1&amp;left=1&amp;panelRight=0">Link to live example</a><br><a href="https://github.com/aholachek/react-animations-from-scratch/blob/master/src/examples/BasicEnterExitExample">Link to code</a></p><p>This example is like a bare-bones version of a <a href="https://reactcommunity.org/react-transition-group/">ReactTransitionGroup</a> that is optimized for calling imperative animations to manage transitions. Here, the parent toggles the isVisible prop to show and hide the child, and the animatingOut state variable makes sure that, even if other updates trigger shouldComponentUpdate before the animation has completed, the exiting elements will be kept in the DOM long enough to transition gracefully.</p><p>I have a setInterval call here updating the element items independent of the entry and exit animations, so that you can see that this setup can handle unrelated updates without hindering the progress of the main animation.</p><p>The HOC wrapper component looks like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8ba110be63217cf39914d92c6ecedb9f/href">https://medium.com/media/8ba110be63217cf39914d92c6ecedb9f/href</a></iframe><h3>Two: Animating component positions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*e3cuuJ1kd2yYqihd0ga6cA.gif" /></figure><p><a href="http://alex.holachek.com/react-animations-from-scratch/?selectedKind=Animation%20Examples&amp;selectedStory=2.%20Object%20persistence&amp;full=0&amp;down=1&amp;left=1&amp;panelRight=0">link to live example</a><br><a href="https://github.com/aholachek/react-animations-from-scratch/blob/master/src/examples/GroupItemsExample">link to code</a></p><p>This example is more complex and provides a better justification for the hand-rolled animation approach. In this animation, there are no elements entering or leaving the DOM. Instead, we want to catch the moment when the groupings have changed, and animate the positions of the children as they move to their new places. For this type of animation, we can use the<a href="https://aerotwist.com/blog/flip-your-animations/"> FLIP technique</a>:</p><ol><li>Record the positions of children right before they are reorganized</li><li>Wait for the browser <a href="https://developers.google.com/web/fundamentals/performance/critical-rendering-path/render-tree-construction">to run layout</a></li><li>Apply transforms to the children in componentDidUpdate, before the changes have been painted, that cause them to return to their pre-update positions</li><li>Initiate transitions to gradually move them back to their updated places</li></ol><p>Below is an example of the animation function that is called twice by the HOC: initially in componentWillReceiveProps, where it stashes the initial positions of the components and returns another function to be called in componentDidUpdate, that will actually handle the transitions with anime.js. As with all of the examples, the component is passed List, the parent ref, by the HOC.</p><h3>Three: D3-style enter, update, and exit animation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/662/1*-Jy8nXX-685_P9O9lbAjTA.gif" /></figure><p><a href="http://alex.holachek.com/react-animations-from-scratch/?selectedKind=Animation%20Examples&amp;selectedStory=3.%20Enter%2C%20update%20and%20delete%20transitions&amp;full=0&amp;down=1&amp;left=1&amp;panelRight=0">link to live example</a><br><a href="https://github.com/aholachek/react-animations-from-scratch/blob/master/src/examples/ArrayUpdateExample">link to code</a></p><p>This example combines techniques from the first two — this time, not only are we animating in new elements and delaying updates until we can animate out exiting elements, but we are also waiting for componentDidUpdate to run layout so that we can smoothly animate the updating items to their new positions in the list before the new items appear. The shouldComponentUpdate function is responsible for sorting ids into the three categories of enter, update, and exit, and passing those lists of ids to the respective animation functions, which use the data-id attribute mentioned above to filter the items to the list that they need to animate.</p><p>If you check out the <a href="http://alex.holachek.com/react-animations-from-scratch/?selectedKind=Animation%20Examples&amp;selectedStory=3.%20Enter%2C%20update%20and%20delete%20transitions&amp;full=0&amp;down=1&amp;left=1&amp;panelRight=0">example in storybook</a>, you’ll see a continually updating number rendered under the animation. This is a prop that is being passed through the animation HOC into the List component. Its purpose is to demonstrate that, when lifecycle events are correctly handled, exit animations can proceed as normal even when other sources of data are updating. The way the HOC facilitates this is by caching the old list of elements for the duration of the exit animation.</p><p>The code in the animations file is a also the most complex out of the three examples, partly because I try to account for some edge cases — like fast-forwarding in-progress animations when a new update occurs before the current animation has had a chance to complete.</p><p>It could still stand to be refined, but if you’d like to look at the current implementation for this example, you can <a href="https://github.com/aholachek/react-animations-from-scratch/blob/master/src/examples/ArrayUpdateExample">view the code here</a>.</p><p>Interested in working for Codecademy? <a href="https://www.codecademy.com/about/jobs">Check out our jobs page</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c66a582c9b65" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/building-animations-in-react-from-scratch-c66a582c9b65">Building Animations in React From Scratch</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PropTypes Validation in React + Karma]]></title>
            <link>https://medium.com/about-codecademy/proptypes-validation-in-react-karma-683c7d52abe?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/683c7d52abe</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Bonnie Eisenman]]></dc:creator>
            <pubDate>Tue, 22 Sep 2015 18:58:00 GMT</pubDate>
            <atom:updated>2015-09-22T18:55:53.581Z</atom:updated>
            <content:encoded><![CDATA[<p>At Codecademy, <a href="https://medium.com/about-codecademy/testing-with-reactjs-at-codecademy-2aec88cc4e36">we use Karma + Jasmine</a> to test our React codebase. We also use PropTypes to document what props each React component expects.</p><p>Problem: we weren’t actually validating the PropTypes, so even though we made an effort to keep them clean, warnings kept sneaking in:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOMSwFU_GFdJWBE3ImrCZQ.png" /></figure><p>PropTypes are important. They’re part of how we document our code, and missing or invalid props are often a sign of lurking bugs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FT4vBVsIhYmD3TOLwpzMHQ.png" /><figcaption>Note that despite the failing PropTypes, our tests are passing!</figcaption></figure><p>We use CircleCI to run our tests, and surface that information in Github. If we could include props validation in our test suite that would be ideal. But it looks like React doesn’t provide any test utilities for prop validation…</p><p>It’s not particularly <em>elegant</em>, but our approach spies on <strong>console.warn</strong> and looks for appropriately formatted log statements.</p><pre>//react_warnings.js<br>export default {</pre><pre>  watchConsole() {<br>    spyOn(console, ‘warn’);<br>  },<br>  propWarnings() {<br>    let propWarnings = console.warn.calls.all().filter((c) =&gt; {<br>      return (c.args &amp;&amp;<br>      c.args.length &gt; 0 &amp;&amp;<br>      /(Invalid prop|Failed propType)/.test(c.args[0]));<br>    });<br>    return propWarnings;<br>  }</pre><pre>}</pre><p>Then a test might look something like this:</p><pre>import ReactWarnings from ‘test_helpers/react_warnings’;</pre><pre>describe(&#39;MyComponent&#39;, () =&gt; {</pre><pre>  beforeEach(ReactWarnings.watchConsole);</pre><pre>  it(&#39;renders without propWarnings&#39;, () =&gt; {<br>    TestUtils.renderIntoDocument(<br>      &lt;MyComponent someProp=&quot;whatever&quot;/&gt;<br>    );<br>  });</pre><pre>  afterEach(() =&gt; {<br>    expect(ReactWarnings.propWarnings().length).toBe(0);<br>  });</pre><pre>});</pre><p>Note that you have to invoke <strong>watchConsole</strong> before you render the component, if you want to catch render-related warnings.</p><p>It’s short, it’s simple, and it works for us.</p><p>If you have a different approach for validating PropTypes in React, <a href="http://twitter.com/brindelle">I’d love to hear it</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=683c7d52abe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/proptypes-validation-in-react-karma-683c7d52abe">PropTypes Validation in React + Karma</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testing with ReactJS at Codecademy]]></title>
            <link>https://medium.com/about-codecademy/testing-with-reactjs-at-codecademy-2aec88cc4e36?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/2aec88cc4e36</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Bonnie Eisenman]]></dc:creator>
            <pubDate>Sun, 05 Jul 2015 14:32:42 GMT</pubDate>
            <atom:updated>2015-07-05T14:32:26.349Z</atom:updated>
            <content:encoded><![CDATA[<p>At Codecademy, we use ReactJS to build our learning environment. We’ve really enjoyed working with React; it’s well-suited to our learning environment, which is for the most part a single-page app.</p><p>Of course, as part of our React setup, we wanted the ability to write tests for our React components! A few months ago, I started exploring our options. Spoiler alert: we settled on <strong>Karma</strong> and <strong>Jasmine, </strong>because it was over <strong>100x faster</strong> than Jest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*whsAQJR9y38L-3DKERyFLw.png" /><figcaption>The Codecademy learning environment. codecademy.com/learn/learn-rails</figcaption></figure><p><em>Note: we don’t use TDD at Codecademy.</em></p><h3>Goals</h3><p>We needed a few things from our testing setup:</p><ul><li>The test suite should be <em>fast</em>, to encourage us to write more tests and save us time;</li><li>We should be able to test our React components <em>effectively</em>;</li><li>The test suite should play well with <em>ES6 syntax</em> and our <em>webpack setup</em>;</li><li>The test suite must be <em>integrated</em> alongside our current integration tests on CircleCI</li></ul><p>If you want to read more about our frontend tech stack, my (Medium-averse, social-media-abstaining) coworker Artur wrote a great <a href="https://artur.co/articles/moving-codecademy-to-es6-webpack-and-react/">post</a> about how we moved to ES6, Webpack, and React.</p><h3>Attempt #1: Jest</h3><p>Jest is mentioned in the <a href="https://facebook.github.io/react/docs/test-utils.html">official React documentation</a>. “We use Jest,” the React team says. OK then. If the React team uses it, it’s probably worth trying!</p><p><a href="https://facebook.github.io/jest/">Jest · 🃏 Delightful JavaScript Testing</a></p><p>Jest is pretty similar to Jasmine, but it introduces some additional features, like auto-mocking of all dependencies. It also makes it easy to fast-forward timers, so that you can check if callbacks have been fired:</p><pre>jest.runAllTimers();</pre><p>After getting Jest set up, I tried writing some tests. Here’s a shortened version of one such test:</p><pre>jest.autoMockOff();<br>require(&#39;babel-core/polyfill&#39;);<br>var React = require(&#39;react/addons&#39;);<br>var RandomizedRow = require(&#39;../randomized_row&#39;);<br>var TestUtils = React.addons.TestUtils;<br><br>describe(&#39;randomized_row&#39;, function() {<br>  it(&#39;can render a single item&#39;, function() {<br>    // Render a row with 1 child<br>    var row = TestUtils.renderIntoDocument(<br>      &lt;RandomizedRow&gt;&lt;div id=&#39;testID&#39;&gt;test&lt;/div&gt;&lt;/RandomizedRow&gt;<br>      );<br>    var renderedRow = TestUtils.findRenderedDOMComponentWithClass(<br>      row, &#39;grid-row&#39;<br>      ).getDOMNode();<br>    expect(renderedRow.textContent).toBe(&#39;test&#39;);<br>    expect(renderedRow.children.length).toBe(1);<br>  });<br>});</pre><p><strong>Jest was slow. It took ~2 seconds to run each test file.</strong> That’s not really tenable.</p><p>Presumably this was due to Jest’s auto-mocking, but we didn’t particularly <em>want</em> auto-mocking, so this was not an acceptable trade-off for us.</p><p>Additionally, Jest doesn’t support ES6 syntax in tests, and it strongly favored relative-path import statements, which we don’t use. We usually write:</p><pre>import MyComponent from ‘components/MyComponent’;</pre><p>rather than:</p><pre>import MyComponent from ‘../MyComponent’;</pre><p>There’s probably a way around this, but I couldn’t figure it out, and it was annoying to deal with.</p><p>It also requires a polyfill in each file, to handle ES6 syntax in our own codebase, and requires you to explicitly disable automocking (which we usually didn’t want).</p><p>In general, it seemed that the Jest project wasn’t as actively maintained as it could be — seems like the main contributor has a <em>lot</em> on his plate. Between that and the slow speed of the tests, I wanted to explore an alternative.</p><h3>Attempt #2: Karma + Jasmine</h3><p>I decided to try Karma and Jasmine next, based on having heard good things about them. I found kimagure’s blog post on setting up React + Karma + Webpack particularly helpful:</p><p><a href="http://qiita.com/kimagure/items/f2d8d53504e922fe3c5c">How to easily test React components with Karma and Webpack - Qiita</a></p><p>With Karma, my main problem was figuring out how to match my karma.conf.js file with our webpack setup. This turned out to be pretty simple to address; I just required our webpack config and made use of it in the karma config.</p><pre>var webpackConfig = require(__dirname + ‘/webpack.config’);</pre><p>Everything was much easier after that:</p><pre>module.exports = function(config) {<br>  config.set({<br>    basePath: ‘webpack/assets/javascripts/’,<br>    frameworks: [‘jasmine’],<br>    files: [<br>      &#39;mocks/globals.js&#39;,<br>      &#39;tests.webpack.js&#39;,<br>    ],<br>    preprocessors: {<br>      &#39;tests.webpack.js&#39;: [&#39;webpack&#39;, &#39;sourcemap&#39;]<br>    },<br>    webpack: {<br>      resolve: webpackConfig.resolve,<br>      module: webpackConfig.module<br>    },<br>    webpackServer: {<br>      noInfo: true<br>    },<br>    reporters: [&#39;progress&#39;],<br>    port: 9876,<br>    colors: true,<br>    logLevel: config.LOG_INFO,<br>    autoWatch: false,<br>    browsers: [&#39;PhantomJS&#39;],<br>    singleRun: true<br>  });<br>});</pre><p>The test looks quite similar to the Jest version.</p><pre>import React from &#39;react/addons&#39;;<br>import RandomizedRow from &#39;components/randomized_row&#39;;<br>var TestUtils = React.addons.TestUtils;<br><br>describe(&#39;randomized_row&#39;, () =&gt; {<br>  it(&#39;can render successfully&#39;, () =&gt; {<br>    var row = TestUtils.renderIntoDocument(<br>        &lt;RandomizedRow&gt;<br>          &lt;div id=&#39;testID&#39;&gt;test&lt;/div&gt;<br>        &lt;/RandomizedRow&gt;<br>      );<br>    var renderedRow = TestUtils.scryRenderedComponentsWithType(<br>      row, RandomizedRow<br>      );<br>    expect(renderedRow.length).toBe(1);<br>  });<br><br>});</pre><p>Note that there’s <strong>less boilerplate,</strong> and Jasmine + Karma is able to fully support ES6 because it plays nicely with our Webpack setup. This test took only <strong>18 miliseconds to run locally, compared with almost 2 seconds with Jest. </strong>There is some setup time, since Karma launches a headless browser, but that’s per-run, not per-test.</p><p>To run tests, we added a simple entry to our package.json file:</p><pre>&quot;scripts&quot;: {<br> &quot;test&quot;: &quot;karma start&quot;<br>}</pre><p>And now we can run our tests with <em>npm test</em>. After that, integrating this into CircleCI was easy.</p><p><strong>The result? Karma + Jasmine was over 100 times faster than Jest, and a better fit for our setup.</strong></p><h3>Surprises</h3><p>We did encounter some surprising issues, like the fact that <em>scryRenderedComponentsWithType </em>appears to ignore child-trees of plain HTML elements. (Sigh.)</p><h3>Conclusion: Karma + Jasmine + Webpack + React = ❤</h3><p>We now use Karma + Jasmine to write tests for our React components, and we’re really happy with the combination.</p><p>I’m always curious to hear what other people are using, though — what works for you? What doesn’t? <a href="http://twitter.com/brindelle">Let me know!</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2aec88cc4e36" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/testing-with-reactjs-at-codecademy-2aec88cc4e36">Testing with ReactJS at Codecademy</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Narrative Product Development]]></title>
            <link>https://medium.com/about-codecademy/narrative-product-development-6a0319502de5?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/6a0319502de5</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Conor McGlauflin]]></dc:creator>
            <pubDate>Fri, 05 Jun 2015 16:19:16 GMT</pubDate>
            <atom:updated>2015-06-05T20:52:04.165Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zOYWkd7ugZfEJe8NkZwamQ.jpeg" /></figure><h4>Using storytelling to improve products</h4><p><strong>This is a case study and call to action, to envision and build products using stories.</strong></p><p>Every product needs a vision, a guiding light to build towards. This can come from many sources — a single voice of leadership, an open source community, maybe a unified team. What I discovered during a project aimed at charting the future vision of our product here at Codecademy was a series of methods that helped our team come together to imagine, and now build such a vision. What unified each of these methods was the ancient tradition of storytelling. But, that’s getting ahead of myself — let me start at the beginning.</p><p>I spent the first day of this project digging through hours of user interviews we had conducted the month prior, and data about how our users engaged with our current product. What I kept coming back to was the countless stories about how people had used our product to change their lives, and in some cases how our product was failing them. This was the beginning, the first step in using stories to build product.</p><p>The following are the 5 key steps I took to create a vision using stories, methods we are continuing to use on a daily basis to build product here at Codecademy.</p><h4>Step 1: Frame the problem and opportunities in stories</h4><p>The first step is to frame the problems and opportunities as they relate to the most important people — users. To do this we used a <a href="http://files.thisisservicedesignthinking.com/tisdt_cujoca.pdf">customer journey</a> which charts the general story of how customers use a product or service, and defines the biggest problems or gaps in the journey.</p><p>A key element in this process is gathering rich information and evidence about who the customer or user is and what their experience is like. To do this we took 20+ hours of user testing and interviews to define the key areas that Codecademy either wasn’t addressing, or needed to improve. This resulted in what we call the ‘learning journey’ illustrated below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*87B92iXCQ_uqs0ogbCR_WA.png" /><figcaption>This is our “learning journey” that shows the high level stages of our users’ learning stories.</figcaption></figure><p>There are many variations of this journey each based on different learner types, but one example of a specific story is Sue’s Story. Sue’s a college student who graduates and uses Codecademy to learn how to code, and ultimately get a job. Sue represents our ‘career learner’ someone looking to gain skills to find a job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*12TGwR3F0eGDpkPbX4zEnw.jpeg" /><figcaption>Our physical site map being used in our office.</figcaption></figure><p>To gain an understanding of how all these problems and user stories related to our current product, I built a physical site map. This was made up of our courses, users, and each main part of our platform. This proved to be effective not only in grasping what we needed to improve, but more importantly, it was a physical space where our team could discuss ideas about how to solve the problems by improving our product.</p><h4><strong><em>Step 2: Solve problems in context</em></strong></h4><p>With the journey and problems mapped, the next step was to begin imagining solutions. At this point, it’s critical to involve as many team members as possible in small structured workshops focused on solving specific problems.</p><p>A great way to do this is with the <a href="http://www.designkit.org/methods/3">How Might We</a> exercise. For every problem you ask “how might we solve this?” and then discuss ideas ranging from technical ideas to business solutions. Be sure to document each solution with a sticky note.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JjhpwfbLdO1irE2nhJoO7w.jpeg" /><figcaption>Results from the How Might We exercise. The purple sticky notes are How Might We questions and the yellow are different ideas about solving them.</figcaption></figure><p>After a few days of these sessions with different members of our team we had ideas spanning technical solutions, business ideas, and wholly new products. I began organizing the solutions based on where they fit within the learning journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UOjcBThVIfgMyhYG3N5SCw.png" /><figcaption>Ideas organized into the learning journey. I grouped ideas into categories and for each idea made a quick sharpie sketch and title.</figcaption></figure><h4><strong><em>Step 3: Stop designing, and write</em></strong></h4><p>Product features and ideas are important but they alone do not make a great experience. For an experience is human, it has depth and often is the result of multiple ideas and features elegantly woven together. This step is where you put your pencil aside, close Sketch or Adobe, and write.</p><p>Every good story has a main character and problems they encounter, so I began with our main character — our target <a href="http://en.wikipedia.org/wiki/Persona_(user_experience)">persona</a>. Then pulling from research I used quotes from users, the key problems that persona faced, and a ton of ideas from our team — everything I needed to start writing.</p><p>I constrained myself to 3 rules for each story: <strong>1.</strong> It must begin the moment they need your product and end when they accomplish their goal (such as getting a job.) <strong>2.</strong> It had to resolve all of the known problems using ideas from the team brainstorms. <strong>3.</strong> It had to explain, in detail the features or product ideas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GXK9RDfq-twAMKDskEeVSg.png" /><figcaption>Examples excerpts from a few of the stories.</figcaption></figure><p>Due to a story’s inherent accessibility, I was able to gather rich feedback quickly. This is the best part of using stories for this step — everyone on the team, from CEO to designer, can read an eight page story and instinctively share if they feel it represents the future of Codecademy. I was able to gather and adjust these stories in a matter of days.</p><h4><strong><em>Step 4: Design features to make the stories reality</em></strong></h4><p>With the stories written and the team aligned, the next step was to do everything I could to make the stories real.</p><p>I had three weeks to move from story to product and to do this I followed three steps. First I used storyboarding to move quickly and explore what would be involved in transforming each story into cohesive product features.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q5_Zhc5hht19g6IS35GChg.png" /><figcaption>Samples of some of the story boards I made. Each story board followed a different user persona through their entire learning journey. The goal was to begin thinking about what products would need to exist to make the stories come true.</figcaption></figure><p>Next, I used the model of <a href="http://www.cooper.com/journal/2014/8/service-blueprints-laying-the-foundation">service blueprints</a> for each key feature (a blueprint is a map that breaks down an experience into all of the actors and elements.) This challenged the ideas with a new level of detail and reality, forcing me to think through what it would take to build them, and where they would fit within our product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ei4Gc4uxc8CprGfJ_xJviQ.jpeg" /><figcaption>Blueprint of how a user experiences a project on Codecademy.</figcaption></figure><p>Finally, I made high fidelity visual mockups of all the key features or products that were essential to the future vision.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TLSaw6dejWQmUfn0m4ytHA.png" /><figcaption>A screenshot of my final vision book. I focused on designing out only the key features that had to be there in order to make the vision happen.</figcaption></figure><h4><strong><em>Step 5: Product roadmap and building</em></strong></h4><p>We had a vision in the form of a story. Within this vision there were many new features and products. So, how did we go about building, testing, and iterating on them? The key here is to act in context of the vision. We prioritized the features based on our current business needs and how we would implement them.</p><p>This last step will differ based on your team or company needs and priorities, but the important thing is to not lose sight of its context and the stories that you’re responding to.</p><p>We’re now a few months into building out this vision and continue to use many of these methods in our daily product development. We’re constantly looking to evolve and improve our product process so please leave comments and questions!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a0319502de5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/narrative-product-development-6a0319502de5">Narrative Product Development</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Transparency With A Capital T]]></title>
            <link>https://medium.com/about-codecademy/transparency-with-a-capital-t-c06ccb37580f?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/c06ccb37580f</guid>
            <category><![CDATA[transparency]]></category>
            <category><![CDATA[codecademy]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[Margot Mazur]]></dc:creator>
            <pubDate>Fri, 22 May 2015 15:29:58 GMT</pubDate>
            <atom:updated>2015-05-22T15:58:56.597Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-67oK5BcdYxyXDuw9-O9vA.jpeg" /></figure><p>How can you trust that a company has your best interests at heart? At a time when we have the constant option of choice, startups are realizing that transparency is crucial in order to develop a great relationship with their users. From Foursquare going <a href="http://blog.foursquare.com/post/118142264388/your-old-foursquare-badges-and-mayorships-evolved">public</a> with future features and goals, to Reddit beginning the use of their new <a href="https://www.reddit.com/r/announcements/comments/3576g2/bringing_back_the_redditcom_beta_program/">beta</a> program, companies are putting more emphasis on user interaction and communication than ever before, emphasizing transparency in the way they talk to their audience.</p><p><strong>When did transparency become all the rage?</strong></p><p>When you’re having an issue with a startup, where do you turn? Do you call their customer service representative? Should you write them a handwritten letter of concern and fax it to their HQ? In today’s age, we reach out to the startups in our lives over social media — and we expect a timely human response and a fix to our problems.</p><p>The impact of a company’s users on their product and brand has risen dramatically over the last decade, thanks to the use of social media. People use their Facebook, Twitter, and Reddit accounts to speak their minds and convey their opinions, making real-time impacts on startups that depend on their users’ satisfaction for survival and support. The increase in individual user power has led to an expectation of transparency from startups by way of announcements, discussions, and replies.</p><p><strong>Using transparency to a startup’s advantage</strong></p><p>For startups, transparency should come with a capital T. Incorporating transparency as a company value will change the way you work with the rest of your team, the way you respond to your users, and how they advocate for you. You can’t please everyone — but you can keep them informed and show that their interests are at the heart of your product.</p><p>Communicating with users about the whats, whys, whens, and hows of your startup will help them feel like you’re on the same page and that you respect them enough to let them in on product decisions and future goals.</p><p>If your startup is experiencing an issue, such as a server going down or features not responding, users will always reach out to see what’s going on. The worst thing you can do is let them down by not responding. Instead of shying away from this type of feedback, embracing it allows for companies to improve their product, explain their features, and save money on hefty QA efforts.</p><p>Users who report issues through product features or on Twitter help advance the idea of transparency by being open with the startup, and expecting the same in return. Technical issues and unpopular product changes suddenly become easier to accept when they are explained by the team in a timely, clear, and direct way.</p><p><strong>Transparency — How We Do It</strong></p><p>OK you get it. Transparency is important. But how do you convey it to your users? At <a href="http://www.codecademy.com/">Codecademy</a>, we have set spaces where we talk about the decisions we make for our company — whether they be engineering, design, or content. Our <a href="http://www.codecademy.com/blog">blog</a> offers a space where we can talk to our users on a level playing field.</p><p>We explain our popular decisions, such as design changes, in the same way that we talk we about less popular decisions, such as sunsetting a current course. It’s a platform we use to offer insight into how we deal with problems that affect our users, giving them an inside look into the intricacies of running a startup.</p><p>Unlike many startups, we use Medium to give an in-depth look into our company and our decisions. Here, Codecademy team members are able to express their opinions about less-talked about decisions, such as design choices and intricate engineering choices. We talk about everything from why we created a certain image or flow to the different languages that our engineers are experimenting with in order to create a more exciting product.</p><p>Our Medium page allows our team members individuality in explaining how they feel on a variety of topics that would otherwise not come to public view. This transparency is unique and allows our users a much deeper view into our culture, thought process, and decisions. Read through our team members’ Medium posts to get a glimpse into our work.</p><p>There’s no better place to communicate with your users one-on-one than on Twitter. We use <a href="http://www.twitter.com/codecademy">Twitter</a> to answer individual questions, let users know of any issues that may come up, and update folks on what’s on our radar. We post photos of our team so people know who is working on the product they use every day. We try to be as transparent as possible with our users, sharing insight and asking for feedback every step of the way so that we can build a better Codecademy and a more satisfied user base.</p><p><strong>Transparency works — period</strong></p><p>At Codecademy, we reach out to our users on a weekly basis through Facebook and Twitter, asking for their feedback on areas where we think we may have opportunities for improvement. This transparency between our brand and our users has allowed us to build a better product.</p><p>We’ve seen that most of the time, frustrated users who get a response explaining the situation will be more happy about the response than annoyed over the issue, continuing to advocate for our brand. Our users report bugs that get fixed, as well as offer their input and answer questions that we ask about our product, helping us create a Codecademy that provides the highest value possible for our learners. That’s transparency at work — clearing up confusion for the startup’s community and letting them know that their experience is our top priority.</p><p>We listened to our users who wanted more hands-on practice with their material and created course projects — distinct areas for learners to work on projects mid-course in order to feel more confident in their ability to code. Today, projects are an immensely popular feature, and we’re expanding to bring more of that hands-on feel to Codecademy courses.</p><p>The opportunities that allow folks to communicate with startups on a human level result in feedback that can be invaluable for a product. Social media allows people to speak their opinions without being shy, and those opinions scale. How are you using transparency within your company?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c06ccb37580f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/transparency-with-a-capital-t-c06ccb37580f">Transparency With A Capital T</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rapid iOS Prototyping with React Native at Codecademy]]></title>
            <link>https://medium.com/about-codecademy/rapid-ios-prototyping-with-react-native-at-codecademy-c4f0a567ee57?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/c4f0a567ee57</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Bonnie Eisenman]]></dc:creator>
            <pubDate>Tue, 21 Apr 2015 14:28:22 GMT</pubDate>
            <atom:updated>2015-03-19T14:43:29.613Z</atom:updated>
            <content:encoded><![CDATA[<p>Codecademy <a href="http://artur.co/articles/moving-codecademy-to-es6-webpack-and-react/">switched</a> to using ReactJS in mid-2014, and it’s been a great experience so far; all of our new frontend development is in React. In January, I headed out to California to <a href="https://www.youtube.com/watch?v=ZM6wXoFTY3o&amp;index=18&amp;list=PLb0IAmt7-GS1cbw4qonlQztYV1TAW0sCr">speak</a> about our experiences at ReactJS Conf. All the talks were great, but the <a href="https://code.facebook.com/videos/786462671439502/react-js-conf-2015-keynote-introducing-react-native-/">keynote</a>, in which the React team announced React Native, was particularly exciting. Writing native iOS and Android apps using ReactJS? Given our excellent experience with using React for the web, I was excited to see what it would look like on mobile.</p><p>Happily, our engineering team budgets time to focus on “Dev Days”: dedicated space for the engineering team to improve our existing codebase and experiment with new technologies. For my Dev Days project I decided to give React Native a spin. We don’t have any mobile engineers, despite having a successful <a href="https://itunes.apple.com/us/app/codecademy-hour-of-code/id762950096?ls=1&amp;mt=">iOS application</a>. Wouldn’t it be awesome if we could take our frontend team’s knowledge of ReactJS and apply it to mobile development? I decided to find out what that might be like.</p><h3>A Two-Day Prototype</h3><p>A few months ago, two of my coworkers had proposed a mobile app, and even done some designs and user testing. I wanted to build out a prototype that represented a working version of that app, and time myself. What kind of resourcing requirements would we need to consider, if we built an app with React Native?</p><p>I spent two days on it. React Native is surprisingly easy to use, even in its current, sparsely-documented state.</p><p>(I have access to React Native because I attended the conference. The “code drop” is more of an alpha release though, and it’s being actively improved day by day. I won’t be sharing code samples or diving into details because it’s not really an appropriate time— that can wait til Native is actually open-sourced!)</p><p>The final result? Well, I didn’t achieve total fidelity to the mocks, but that’s okay. It works!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Ta3dczPVrMi0TM_n8A3hw.jpeg" /></figure><p>The prototype app is a simple HTML quiz; nothing fancy.</p><p>Working with React Native was interesting, to say the least. In many ways, it feels just like ReactJS for web. You open XCode and hit ‘run,’ but after that you can switch back into your usual text editor and work with ordinary Javascript files. One of the main pain points of developing for mobile is also eliminated. Instead of rebuilding your application to experiment with changes, just hit CMD+R, and the app refreshes almost instantly. The React team has also added some useful error messages and the ability to use Safari developer tools to debug your Native application.</p><p>Basically, it feels like web development, just targeting a different platform.</p><p>Using Facebook’s approach to CSS on Native was probably the most significantly different piece of the project. Everything in React Native uses a flexbox implementation for layout. Additionally, you have to use inline styles; your CSS becomes a collection of Javascript objects, essentially. I don’t mind this approach, but it did take some getting used to, and I’ll have to spend more time pondering best practices.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*nv6SF2JZ6K8xTj3MTHunHw.png" /><figcaption>A basic HTML quiz. The app asks you to select which HTML tags are appropriate in a given context, then provides you with feedback.</figcaption></figure><h3>React Native is Important.</h3><p>I’m a big fan of React’s approach to building user interfaces, so I’m happy to see React on mobile. I like that components are just little state machines, built one on top of the other; I like that it pressures you into writing better, more modular code.</p><p>For a small startup like Codecademy, being able to share expertise between frontend and mobile developers is also an intriguing opportunity. We currently have nine engineers, so our resourcing constraints are quite different from a company the size of Facebook. I don’t know if we’ll be using React Native for our next mobile offering, but it’s definitely a possibility that I’m excited about.</p><p>React Native has a lot of potential to change the way we think about a lot of things: how we write applications for multiple platforms, how we handle styling, what it means to prototype applications.</p><p>All in all? I’d call this experiment a definite success, and I’m excited to see what happens with React Native from here.</p><p>PS: Want to come work with me? <a href="http://www.codecademy.com/about/jobs">We’re hiring</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4f0a567ee57" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/rapid-ios-prototyping-with-react-native-at-codecademy-c4f0a567ee57">Rapid iOS Prototyping with React Native at Codecademy</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redesigning Our Learning Environment: What We Learned]]></title>
            <link>https://medium.com/about-codecademy/redesigning-our-learning-environment-what-we-learned-a001fac0708f?source=rss----396b101c94---4</link>
            <guid isPermaLink="false">https://medium.com/p/a001fac0708f</guid>
            <dc:creator><![CDATA[Andres Iga]]></dc:creator>
            <pubDate>Tue, 10 Feb 2015 19:42:58 GMT</pubDate>
            <atom:updated>2015-02-10T19:42:47.739Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OtfJ9LMedNEICnK1gkZNEQ.png" /></figure><h3>Introduction</h3><p>In a previous post, <a href="https://medium.com/about-codecademy/redesigning-our-learning-environment-process-101d41eedd6">the first part of “Redesigning our Learning Environment”</a>, I went over the various stages of our design process. During this stage, we learned a few things that many design teams can apply to their own process, especially when working on a dedicated product. In this post, part two, I will go over 5 key learnings: (1) Embrace Product-Principles, (2) Design for a System, (3) Leverage Modularity, (4) Contextualize the UI, and finally (5) Minimize Cognitive Overload.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3mX7e8x7AnEaGtZNxC0XTA.jpeg" /><figcaption>The Codecademy learning environment.</figcaption></figure><h3><strong>1. Embrace Product Principles</strong></h3><p>Product principles are fundamental values that help companies make decisions about a product. For a design team, they provide a high-level style guide that helps steer all design decisions — from user interactions to visual designs.</p><p>While these are usually quite general, it’s the design team’s job to interpret and translate our product principles in order to inform even the most detailed design decisions. Let’s take two of Codecademy’s product principles as an example:</p><ol><li>Codecademy believes in learning by doing.</li><li>Codecademy is accessible and approachable.</li></ol><p>The first principle has helped us guide big product decisions that define the user experience: where others use videos or images, we use interactive learning. While designing our new environment, we also knew we had to support the interactions that users find in real development tools, since we’re not just teaching content, but the full coding experience. Therefore, it’s not enough to show users an image of the file structure for the application they are building — they should be able to explore and interact with files. As a consequence of this principle, we ended up designing a file navigator that allowed users to interact with files and directories very close to how they would in real life.</p><p>The second principle, relating to accessibility and approachability, has helped guide our decision to not only incorporate more animations/transitions in the learning environment, but also the feel and timing of these.</p><h3>2. Design for a System</h3><p>Think like a developer. Reuse your work when possible, and design solutions that can be used over and over. This means one-offs should be minimized: you’ll thank yourself for it, the Engineering team will thank you for it, and users will thank you for it. Here’s why: implementation of solutions based on design patterns is faster and easier to maintain, and for the user, it means that they don’t have to learn new behaviors, and that they know what to expect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gkwv0jSnlXK41BqNvLFI5w.jpeg" /></figure><p>In our learning environment, module behavior in the grid was designed with this in mind. While there are very specific exceptions that are justified by the idea of providing a better learning experience, we designed all modules to have shared functionality, such as collapsing and the ability to go fullscreen, as well as shared layout logic — any module can be at any place in the grid at any time.</p><h3>3. <strong>Leverage Modularity</strong></h3><p>A product is not only a system of rules, but also a system of parts. Being able to discern and define these parts clearly is a key first step to providing a focused and friendly user experience, for it facilitates the implementation of lessons 4 and 5.</p><p>Here’s a general example of how we leveraged modularity. Our previous approach to a coding environment assumed that the lesson content, the code editor and the preview/output console were a unit. Acknowledging that these were individual parts that could be removed or surfaced in each exercise allowed us to come up with a modular playground for the Content team to try new teaching approaches and exercise types, resulting in an improved and more engaging user experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cpjyfRjTKt8Ssm2M0oBySA.png" /><figcaption>Some of the modules and how they fit into our grid.</figcaption></figure><h3>4. <strong>Contextualize the UI</strong></h3><p>UI elements and functionality should only appear when they are relevant to the user. This is working with the same logic as contextual menus: offer users actions that matter depending on their task at the moment, or the part of the interface they are interacting with. This can be at the general interface level or at a modular level. At an interface level, elements that situate the user and provide important general context should be kept visible at all times.</p><p>For us, this meant separating the elements users might need at any time, like navigation and progress, and making them easily accessible in the Shell, which doesn’t change exercise to exercise. At a modular level, options like the ability to reset the state of the users’ files or applications only appear on exercises that handle files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*9a0VExH3WWwNiTiF133eLw.jpeg" /><figcaption>Elements and functionality in the code editor surface as they are needed. This logic carried through all the different modules.</figcaption></figure><h3>5. Minimize Cognitive Load</h3><p>By having a modular system that contextualizes functionality, you can provide a clear, focused experience for users. Often times, interfaces may contain elements that are unnecessary or distracting — resulting in cognitive overload for users. The best way to prevent this is by using progressive disclosure, surfacing UI elements as they are required by the user.</p><p>In our Learning Environment, we do this by surfacing the different modules users require in each exercise, and hiding the ones that they don’t. The modalities below represent the distinct layouts that are possible within this framework. Furthermore, we take this a step further by removing extraneous UI elements or functionality at a modular level when they’re not needed. The code editor, for example, has the following parts: (1) file navigator button, (2) file tabs, (3) file body / editor, and (4) file path, and (5) Run button. If a user is not dealing with multiple files in an exercise, then we remove the file navigator button, tabs, and the file path. On the other hand, if a user is working within a complex application and modifying multiples files at once, then we present the code editor with all its parts. This helps reduce users focus on what’s important and relevant to the exercise.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xK1r0uBhzvvhSFLDpSd15g.jpeg" /><figcaption>An example of the browser component in fullscreen.</figcaption></figure><h3>Conclusion</h3><p>We hope that sharing the process and lessons of redesigning our Learning Environment, you can find some inspiration and tips to improve your own team’s process. For us, it’s very helpful to look back at what we’ve done and reflect on it. We’re excited about the new Learning Environment, and we’ve seen great reactions from our users. At the same time, we continue to receive feedback and, keeping the five lessons outlined above in mind, we’re excited to keep iterating on our new platform.</p><p>This is one of the many things currently brewing at Codecademy. Want to know more about our design projects? <a href="http://codecademy.com/about/jobs">We’re hiring!</a> Send me an email or follow me at <a href="http://twitter.com/andresiga">@andresiga</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a001fac0708f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/about-codecademy/redesigning-our-learning-environment-what-we-learned-a001fac0708f">Redesigning Our Learning Environment: What We Learned</a> was originally published in <a href="https://medium.com/about-codecademy">About Codecademy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>