DEV Community: Sonny Li

Monthly Challenge #4: Valentine's Day 💘

Sonny Li — Thu, 09 Feb 2023 19:08:57 +0000

What better way to celebrate Valentine's Day than by sharing a poem with your friends and family? In this challenge, you will create a poem on a web page using HTML. 💌

Requirements:

Use a combination of at least five common HTML elements, such as headings, paragraphs, lists, and text formatting.
The poem can take on any form you like! You can freestyle with as many lines as your heart desires, but here are some suggestions for common poem types:
- Sonnet (14 lines)
- Haiku (3 lines; 5 syllable, 3 syllables, 5 syllables, respectively)
- Limerick (5 lines; rhyme scheme AABAB)

Bonus:

Make your Valentine's Day poem as pretty or complex in style (background color, border, etc.) by doing one of the following:

Use a <style> element in the <head> of the document.
Apply a global style attribute to various elements in the <body> of the document.

Try our free course if you need a quick refresher on HTML!

Submit a screenshot of your web page by Feb 14th for a chance to win a special surprise! If you want, you can tag the person the valentine is for so they can see it.

May the best poet win. 💕

Monthly Challenge #3: Morse Code 🆘

Sonny Li — Mon, 02 Jan 2023 22:06:09 +0000

Morse Code

Morse code is a communication method to encode characters as dots (.) and dashes (-), developed in the 1830s.

January Challenge

Create a translate() Python function that takes in a message and converts it to morse code.

Post the code/output screenshot in the Twitter thread by Jan 14th for a chance to win a Codédex hoodie! 🎁

// Detect dark theme var iframe = document.getElementById('tweet-1609910099824496647-936'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1609910099824496647&theme=dark" }

Monthly Challenge #2: Holiday ASCII Art ️ ️☃️

Sonny Li — Thu, 01 Dec 2022 18:10:39 +0000

Welcome to Codédex's second Monthly Twitter Challenge! This one is also created by our SWE Intern, @asiqurrahman. 🙌

// Detect dark theme var iframe = document.getElementById('tweet-1598365914134679552-665'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1598365914134679552&theme=dark" }

ASCII Art:

ASCII art is a computer graphic design technique that piece together a picture using characters defined by the ASCII Standard from 1963.

Challenge:

Using your coding language of choice, create a holiday-themed ASCII art in the terminal. Be as creative as you can. And it has to be original! 🎅🏼🎄☃️❄️

Post your code & screenshot below by Dec 14th for a chance to win a limited edition Codédex sweater mailed to your door by Christmas morning! 🎁

Codédex Launch on Product Hunt! 🚀

Sonny Li — Mon, 07 Nov 2022 12:01:08 +0000

Hi Devs!

It’s Sonny from Codédex –– a brand new learn to code platform for Gen Z.

We’re a small-but-mighty team based in Brooklyn, NY but have teammates across the globe.

Since June 2022, we’ve gone full in on our mission to empower the next generation of builders and dreamers. And today, we are finally launching to the world on Product Hunt — please support us!

Head over to Product Hunt to give us an upvote! We are aiming for the Top 5 Products of the Day and it would mean the world if you can give us 30 seconds of your time.

⬆️ https://www.producthunt.com/posts/codedex ⬆️

Here's a preview of the site:

Lastly, huge shoutout out to the whole team: Dharma, Malcolm, Asiqur, Jerry, Rose, and Lil for working on this night and day for the past few months. LFG team!

Happy coding,
Sonny 🤠

How do programmers say "I love you"? 🤔

Sonny Li — Thu, 03 Nov 2022 16:04:42 +0000

Note: WRONG answers only!

Feel free to reply in the comments or in the Twitter thread:

Codédex

@codedex_io

How do programmers say "I love you"? 🤔
Wrong answers only.

00:16 AM - 03 Nov 2022

That's all! Happy Thursday, Devs! 💖

Monthly Challenge #1: Palindrome 🔤

Sonny Li — Tue, 01 Nov 2022 16:39:08 +0000

Welcome to Codédex's first ever Monthly Twitter Challenge! This one is created by our SWE Intern, @asiqurrahman. 🙌

// Detect dark theme var iframe = document.getElementById('tweet-1587072993448058883-356'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1587072993448058883&theme=dark" }

Palindrome:

A word, sentence, or number that reads the same forward or backward (e.g., racecar, civic, and 121).

Challenge:

Create a Python function that:

Takes in a string as a parameter.
Checks if it's a palindrome.
Returns True if it is or False if it's not.

Requirements:

📦 Don’t use any packages.
💬 Make sure to comment the code.

Post your program screenshot in the Twitter thread.

And we will pick a random winner by noon this Friday. The prize is a free Codédex tee and bragging rights! 🏆

Update:

We have a winner to the Codédex Monthly Challenge: Palindrome! 🥁...

Congrats to Michael Gonzalez! 🇪🇨

The reasons being:

Solution covers string & number
Good comments
Good breakdown of the functions
First to post bonus

Here's the solution:

// Detect dark theme var iframe = document.getElementById('tweet-1587105952607703040-740'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1587105952607703040&theme=dark" }

Build a Discord Bot with Python

Sonny Li — Thu, 01 Sep 2022 20:13:27 +0000

Prerequisites: Python fundamentals
Versions: Python 3.10
Read Time: 45 minutes

Introduction

In this tutorial, we'll learn how to set up your Python programming environment, create and register a bot using Discord Developer Portal, and write a few lines of Python code to respond to users' messages in Discord. We'll also provide a breakdown of each line of code for those who want to get a deeper understanding of how it all works.

The Discord bot that we are going to build will listen for the keyword $meme and responds with a random meme from Reddit.

The final result will look like this:

Let's dive in!

Requirements

Before we get started, you will need a few things if you don't have them already:

Python 3 installed.
pip (package installer) installed.
A Discord account.
A Discord server with "Manager Server" permissions.

How Does a Discord Bot Work

First, let's zoom out a bit and think about this question: "What does it mean to code a Discord Bot?" Simply put, a bot is nothing more than a computer program that performs some useful actions.

Because Discord wants bots to be able to do useful things, they have allowed developers to access parts of its system in their code, such as automatically responding to messages or helping with the server's admin functions (e.g. check out these popular Discord Bots).

Today, we're focused on getting our bot to read and write messages, so let's see how that works.

From the crude drawing above (I'm an engineer, not an artist), we can see how users and bots connect to the Discord backend. Each user interacts with the Discord backend to write and read messages. Then, the Discord backend servers will broadcast an event to any program listening that a new message has been posted. All we have to do is write our program to respond to message events (named bot.py here) and connect it to the Discord backend by using their API.

API (Application Programming Interface) is just a fancy terminology to define how one program talks to another program. In our case, Discord's API allows us to read and send messages to its backend servers.

First, we'll have to create and register our bot from Discord's Developer Portal.

Setting Up Discord Developer Portal

We'll be creating and registering our Discord Application inside the Developer Portal. Then, we will create a Bot for the application and get the required permissions.

Step 1. Go to Developer Portal

Visit https://discord.com/developers/applications and sign in if you haven't already.

Step 2. Create a New Application

To let Discord know we're going to be connecting to their backend servers, we need to register an application and set up the required permissions.

Click "New Application" on the top right.

Next, give your application a name. Here, we are calling ours MemeBot:

Step 3. Add a Bot to Your Application

Find the "Bot" tab in the left panel:

And click "Add Bot":

Step 4. Get the Token for Your Application

This step is important because we'll need this Token for later. This Token is similar to a password for your application. Anybody who has this can control it. (So make sure to never share your bot token with anyone, or upload it on GitHub by mistake!)

Click "Reset Token", write it down somewhere safe and definitely don't put it in any public place.

Step 5. Invite Application to Your Server

Now that we've set up our first application, we have to create an invite, to get our bot into our Discord server. To do that we can click URL Generator and select the following permissions. In the screenshot below, we are telling Discord to create an invitation link for our application with the scope "Bot" and that bot should be able to "Send Messages." (Note: Be careful with granting the all-powerful "Administrator" permission to your bot).

This is the link to invite our application (Discord bot) into a Discord server. Copy and paste this link into another tab in your browser and invite the bot into the Discord server that you want.

You can confirm if this worked by checking for this message in your Discord server.

Alright, now that we’ve set up our coding environment and got the necessary permissions from Discord for our new application, let’s write some code.

Writing the Python Code

Installing discord.py

The code that we will write, will be responsible for the creation of the bot that will connect to the Discord backend using Discord APIs.

The complicated part about writing this program is how we're going to interact with the Discord API. While we can read the API documentation and send HTTP requests directly to Discord, we have an easier way.

We'll be using a Python package called discord.py which is a simple wrapper around the Discord API. A wrapper provides a way to access an API through a particular programming language, in this case, Python!

If you are using Mac, run the following command in the Terminal to install it:

python3 -m pip install -U discord.py

If you are using Windows, then the following command should be used instead:

py -3 -m pip install -U discord.py

What did we just do here? We just installed a Python package from pip the package installer, which is just another way of saying we downloaded code that someone kindly wrote and uploaded to a public repository.

Log Into the Discord Server with the Bot

Let’s create a new file called bot.py in a new directory. This is the main file where we'll code the logic to make our Discord bot. Now paste the following code into it:

import discord

class MyClient(discord.Client):
  async def on_ready(self):
    print('Logged on as {0}!'.format(self.user))

client = MyClient()
client.run('Your Token Here') # Replace with your own token.

Let’s go over this block of code line by line.

import discord

class MyClient(discord.Client):
  async def on_ready(self):
    print('Logged on as {0}!'.format(self.user))

First, we've imported the discord.py package that we just installed and created our own class MyClient which we will use to interact with the Discord API. We create this class by extending from the base class discord.Client. This base class already has methods to respond to common events. For example, the on_ready() function above will be called when the Discord bot's login is successful.

discord.py works around the concept of events. There are other types of events (e.g. messages) that we will see later, but for now here's the definition of events from their website:

An event is something you listen to and then respond to. For example, when a message happens, you will receive an event about it that you can respond to.

Finally, our last two lines of code instantiates the MyClient class and calls run, which is the main way to start the client. The client will use the given token (which you should have saved from before) to authenticate itself to the Discord backend servers.

client = MyClient()
client.run('Your Token Here') # Replace with your own token

Running the Bot

You can run this code by typing in the following in your terminal.

python3 bot.py

As long as you keep this program running, your Discord bot will be online.

If you see this output in your terminal, then your Discord bot has successfully logged into your Discord server.

Logged on as MemeBot#3995!

Responding to Messages

Next, we want our bot to read messages in a Discord channel and respond to them.

Add the .on_message() method to the MyClient class like the following:

async def on_message(self, message):
  if message.author == self.user:
    return

  if message.content.startswith('$hello'):
    await message.channel.send('Hello World!')

The .on_message() method gets called automatically anytime there is a new message in a channel where our bot is located. In our method:

We are first checking if message.author == self.user, if the bot is the one sending the message in the chat. We don’t want the bot to keep responding to its own messages.
Then, we have some code to respond to a special keyword $hello.

Let's try it out. Run the command python3 bot.py to start our program.

Now, add Memebot to any channel and type the word $hello in that channel and see what happens:

We've successfully programmed our bot to log into Discord and respond to our messages. But can we go further?

How to Respond with Memes

What if instead of responding with a text message, the bot responds with memes? Well that sounds like a lot of work.. buuut the cool thing about programming is that we can reuse other people’s work (yay for open source).

Check out this Github repository: https://github.com/D3vd/Meme_Api. This API returns a JSON response containing information about random memes from Reddit. Hmm, let’s see how it works by visiting this URL: https://meme-api.herokuapp.com/gimme.

Here is the response that I got:

{
  "postLink": "https://redd.it/w0teq0",
  "subreddit": "me_irl",
  "title": "me_irl",
  "url": "https://i.redd.it/ztpkxx6yl0c91.png",
  "nsfw": false,
  "spoiler": false,
  "author": "ozgonngu",
  "ups": 110,
  "preview": [
    "https://preview.redd.it/ztpkxx6yl0c91.png?width=108\u0026crop=smart\u0026auto=webp\u0026s=e3db2a1ed5ee73480224b55b16fcb38925ea9095",
    "https://preview.redd.it/ztpkxx6yl0c91.png?width=216\u0026crop=smart\u0026auto=webp\u0026s=aaec73a28c4c0b2bc47f4f9722be2fdb8ba95893",
    "https://preview.redd.it/ztpkxx6yl0c91.png?width=320\u0026crop=smart\u0026auto=webp\u0026s=90495a39d05f6d9d8975fb776887c08f65ece2c4",
    "https://preview.redd.it/ztpkxx6yl0c91.png?width=640\u0026crop=smart\u0026auto=webp\u0026s=b291abfb8f85b5826f001dee881570e694bdb46c",
    "https://preview.redd.it/ztpkxx6yl0c91.png?width=960\u0026crop=smart\u0026auto=webp\u0026s=7afc3f2532c7017a0045ae50777a18a2e452183e",
  ],
}

It looks like the url field here contains the link for the meme's image. How about we have our bot respond to user's messages with this image?

Integrating the Meme API

Let's paste these lines of code to the top of the file.

import requests
import json

def get_meme():
  response = requests.get('https://meme-api.herokuapp.com/gimme')
  json_data = json.loads(response.text)
  return json_data['url']

requests package allows us to make HTTP requests to any URL. In this case we're calling the GET method to the URL that will give us the meme data.

json package allows us to read JSON data. This is useful since most data passed around on the web is in the JSON format, like the JSON response we saw above.

We need to install the requests package to import it. Run the following command:

python3 -m pip install requests

Now all we need to do is call get_meme() inside our bot's on_message() method. Let's also change the keyword from $hello to $meme since it's more fitting. Your code should look like this:

import discord
import requests
import json

def get_meme():
  response = requests.get('https://meme-api.herokuapp.com/gimme')
  json_data = json.loads(response.text)
  return json_data['url']

class MyClient(discord.Client):
  async def on_ready(self):
    print('Logged on as {0}!'.format(self.user))

  async def on_message(self, message):
    if message.author == self.user:
      return
    if message.content.startswith('$meme'):
      await message.channel.send(get_meme())

client = MyClient()
client.run('Your Token Here') # Replace with your own token

Time to test it out!

Just remember you need to close and restart your program. Press control+c to close the currently running program in the terminal and then, run python3 bot.py again.

The moment of truth...

Success! 🎉

Final Words

That's all it takes to set up and code a Discord bot in Python! Just a note: the bot will respond to you as long as the program is kept running. If you close your terminal or turn off your computer, it will no longer be running. If you want to keep the program running forever, we’ll have to deploy it to another computer in the cloud. However, that is a lesson for another day.

Hope you enjoyed the tutorial. If you have any questions, you can DM me on twitter at @hongjjeon.

More Resources

About the Author:

Hong Jeon is a Software Engineer at Waymo (formerly known as the Google self-driving car project). Hong discovered his passion for sharing knowledge in college during his time as a Teaching Assistant in several programming classes. You can catch him on Twitter at @hongjjeon.

Visualize YouTube Data with Plotly Express

Sonny Li — Wed, 17 Aug 2022 19:05:00 +0000

Prerequisites: Python fundamentals, Microsoft Excel
Versions: Python 3.10, Plotly 5.9
Read Time: 45 minutes

Introduction

So you want to learn about making data visualizations, huh? Well, you’re in the right spot!

Data visualization is translating data into a visual representation to make it easier on the human eye. It makes communicating complex ideas more effective, quick, and easy to follow. It is super important as it makes data more accessible and digestible.

Plotly Express makes it easy to begin learning this process. It is an easy-to-use, high-level module that creates common figures such as line graphs and scatter plots. Plotly was actually the first library I used when I started my journey in data!

In this tutorial, we will create data visualizations of popular YouTube channels using Python, Plotly Express, and Google Colab. We will use a histogram to look at subscriber counts, a pie chart to compare video categories, and a box plot to find patterns in the years that creators started YouTubing.

Let’s get into it (yuh)!

Setting Up

First, visit colab.research.google.com and start a "New notebook".

After that, make sure you have the latest version of Python on your machine. You can check this by typing $ python --version in the Windows command prompt or the terminal on Mac and Linux. It would be best if you were running Python version 3.10 or above.

Once you have checked this, pull up the Plotly Express docs page. It will come in handy while working. Finally, download the dataset used for this tutorial from down below. There would not be a data visualization without some data!

About the Dataset

For this tutorial, we will use the "Most Subscribed YouTube Channels" dataset from Kaggle. The file is called most_subscribed_youtube_channels.csv. You can download it here.

As the name suggests, it contains data about the top 1000 YouTube channels.

There are seven columns:

rank: Rank of the channel as per total subscribers (1-1000)
youtuber: Channel name
subscribers: Total number of followers
video views: Total views of all the videos combined
video count: Number of videos uploaded
category: Channel genre
started: The year that the channel started

It looks something like:

We have made acquaintance with our dataset. Now, let’s jump into some visualizations!

Importing the Data to Google Colab

First things first (I’m the realest), we are going to import our data into our notebook. After downloading your dataset, you should return to your handy dandy Google Colab notebook.

Inside the notebook, go ahead and input the following:

from google.colab import files

uploaded = files.upload()

Press the play button, and there will be a prompt to upload files from your computer. Look in your local drive for the dataset (most_subscribed_youtube_channels.csv) and upload the file.

You should have something like this!

Importing Pandas and Declaring a DataFrame

Pandas is the most widely used open source Python package to perform data analytics. To use it, we will import pandas as pd. pd serves as the alias (nickname) for referring to the Pandas package in our program.

After importing Pandas, we will need to import io. Doing this will let us import our data into a DataFrame and work with file-related input/output operations:

import pandas as pd
import io

Once you have done that, we need to create a Pandas DataFrame. A Pandas DataFrame stores data as a 2-dimensional table in Python. As analysts, we want to be quick in generating graphs, so we can take our time analyzing and reporting our findings. And DataFrames are a great way to structure our data; they are fast, easy to use, and integral to the Python data science ecosystem. You can use any shorthand name for the DataFrame variable, but for this example, we will use df.

The df variable will store the DataFrame returned from the pd.read_csv() method. To do that, you would put in pd.read_csv(io.BytesIO(uploaded[file_name.csv])). This line reads our CSV (comma-separated value) file and returns it as a DataFrame.

And lastly, use the display() function to show the df DataFrame.

You should have the following after completing the steps above:

import pandas as pd
import io

df = pd.read_csv(io.BytesIO(uploaded["most_subscribed_youtube_channels.csv"]))
display(df)

Your notebook should now look like this:

Notice how in some of the numeric columns, there are commas in between the numbers? Let's take out the commas using:

df = df.replace(",", "")
display(df)

Here, we are using the .replace() method to replace all occurrences of commas "," with nothing "".

For the next section, we will be creating three different graphs:

A histogram to look at subscriber count.
A pie chart to analyze video categories.
A box plot to explore the different years people start YouTubing.

Let’s kick things off with the histogram!

Section 1: Make a Histogram

Normally, people will import their library during setup. However, I like to have my imports and graph code together. Therefore, we are going to import the Plotly Python package by writing import plotly.express as px. px will serve as the alias for the package in this portion of the process. After you have imported Plotly Express, we will be ready to start on our histogram!

The import statement should be as follows:

import plotly.express as px

Creating a histogram in Plotly Express is so much easier than you think. Do you know how we create them? Drum roll, please… 🥁

fig = px.histogram(df, x="subscribers", title="Subscriber Count")
fig.show()

Alright, let’s break down this line of code.

First, we need to declare a variable fig. fig will allow us to work with the Plotly Express library that is accessible using the px alias. Remember px from earlier? We use it to determine the type of graph we want to utilize. For example, we typed out px.histogram() because we wanted to plot a histogram.

The arguments passed in the method call are:

The DataFrame df.
The x value that needs to be displayed in the histogram. Since we are looking at subscriber count in this exercise, the x value will be the name of the column that contains the subscribers data in the DataFrame.
The name for our graph. We do this through the title variable. Make sure you put quotation marks around them since they are considered a string.

After we do this, we will use fig.show(), and the notebook should display something like this!

There is so much going on right now in the histogram, so let’s take it step by step.

The first thing we want to do is pay attention to our axes. On the x-axis, we have our variable subscribers. On the y-axis, we have the count of channels with subscribers in that range. In histograms, the bars show us frequency rather than a solid number of things. For our example, we can see a high frequency of YouTubers with between 0 and 40 million subscribers.

Also, a quick shoutout to the channel all the way at the end that made it to 200 million (T-Series). We already know their fan base is grinding.

Section 2: Make a Pie Chart

We are going to do the same thing we did before, but this time we will create a pie chart. For this pie chart, we are going to analyze the different video categories and the top channel they belong to.

All we need to do is replace px.histogram(df, x="subscribers") with px.pie(df, values="subscribers" names="category", title="YouTube Categories"):

import plotly.express as px

fig = px.pie(df, values="subscribers", names="category", title="YouTube Categories")
fig.show()

However, this time we need to pass the following arguments to our method call:

values from our data that will represent a portion of the pie chart.
names that will represent the names for those regions of the pie chart. For this part, you would need to use a column with numeric values for the values argument and a column with string values for the names variable.
title to name the graph. You can choose whatever name you want here, but for the sake of this example, we will call our graph “YouTube Categories”.

That’s it. All that’s left now is to display the pie chart using the fig.show() method.

You should end up with something like this:

Pie charts are very straightforward to read. The bigger the chunk, the greater quantity we have. We can see here that the top category in our dataset is Music (24.9%). Coming in at number two is Entertainment (22.1%).

Section 3: Make a Box Plot

I hope you all aren’t too square to make a box plot. Box plots can show us how spread out our data is. For this example, we are going to use a box plot to analyze the different years people start YouTube.

Sticking to the theme of simplicity, all we have to do to create our box plot is input the following:

import plotly.express as px

fig = px.box(df, y="started", title="Years Started")
fig.show()

The px.box() method follows the convention we have been using in this tutorial:

First, we passed in our DataFrame, df.
Then, we passed in our y variable, started.
Finishing things off, we named our graph “Years Started”.

And like before, the graph is complete but isn’t shown on the notebook page. So, to show the graph, we use fig.show() method.

It should look something like this:

Like that one Tegan and Sara song, let’s get a little bit closer with our graph. In a box plot, we have our minimum value, lower fence, Q1, median, Q3, and maximum value. For this tutorial, we will only be looking at our lower fence, median, and maximum.

In the lower fence, we have the year 2005. This conveys that the earliest top channels got started in 2005. Talk about being there from the very start!
The median, 2013, represents the average year our top channels started their career. Ah, 2013. What a time to be alive.
Our maximum value was 2021. This was the latest year a top channel in our dataset started. As they always say, it's never too late to begin your journey to the top!

Wrapping Up

Congrats, you just created three data visualizations analyzing the top dogs on YouTube!

Many people assume data visualization is such a complex thing, but it can be as easy as running a few lines of code. One piece of advice I would give you is to practice using one type of library for your first few months of learning data visualizations. It will give you the opportunity to get the hang of things and learn about your preferences.

More Resources

About the Author:

Miracle Awonuga is a senior at Belmont University studying Data Science and Video Production. Lately, she has been working on WaffleHacks, a student-led hackathon as the Co-Director of People and Communications. 🧇

Can You Guess the Word? (Python Edition)

Sonny Li — Wed, 03 Aug 2022 17:33:00 +0000

Happy Wednesday! Here are three Rebus Puzzles for all the Pythonistas out there! 🐍

Can you guess the message in each of the three images?

Codédex

@codedex_io

Can you guess the message in each of the images? Hint: It’s all Python related! 🐍

And don’t share the answers! 🤫

#Python #Python3 #PythonProgramming #PythonLearning #CodeNewbie #100DaysOfCode #Programming #Coding

17:00 PM - 03 Aug 2022

Tag a Python friend, but don’t share the answers! 🧠

8-Bit Learn to Code Platform!

Sonny Li — Thu, 28 Jul 2022 16:05:00 +0000

👋 Hello Devs!

I’m Sonny, Founder and Chief Vibes Officer of Codédex, a brand new learn to code platform for high schoolers and college students.

We are beyond excited to announce that we just launched! 🥳🚀🎉

https://www.codedex.io ✨

// Detect dark theme var iframe = document.getElementById('tweet-1552680081838989316-779'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1552680081838989316&theme=dark" }

After working at the intersection of education and technology for the past seven years, I found that project-based learning and gamification are the most effective ways to keep young students engaged in their coding journey.

Mix that in with a touch of 8-bit aesthetics, and we aim to create nothing short of a magical experience. 👾

This v1.0 launch includes:

📱 Mobile view
🔓 Challenge unlock
🏃‍♂️ User progress
⏳ User streak
📛 Badges
🛠 Project tutorials
🏗 React & Next.js

Please check out Codédex and let me know what you think! 🙏

P.S. Here’s the team saying hi:

Learn LOLCODE

Sonny Li — Tue, 02 Apr 2019 02:28:00 +0000

Happy April Fool's! To celebrate, my coworker @joshuakgoldberg wrote a brief LOLCODE course on Codecademy. And yes, it's real. However, it's an easter egg course, meaning, it doesn't live in the catalog. You can only access it with the secret link:

✨ Learn LOLCODE ✨

Inspired by the old lolcat memes, LOLCODE is an esoteric programming language with catchphrases like I CAN HAS and KTHXBYE in place of traditional keywords.

P.S. The course also features some of our team members' cat babies! 😻