Forem: Saul Costa

Free coding courses through May!

Saul Costa — Tue, 28 Apr 2020 18:26:26 +0000

While you are home staying safe and keeping others safe, we want to make sure you have everything you need to keep learning coding and working on your projects. That's why a couple of weeks ago, we decided to make all of Next Tech's interactive courses and sandboxes free through April. Now, we're extending that through May!

Staying home is incredibly important, but so is your ability to continue learning new skills. With Next Tech courses, you can learn coding, web development, data science, and other skills directly from your browser with hands-on projects. No downloads required!

Here are some of the top courses on Next Tech right now that other dev.to readers have enjoyed:

Just need a spot to write some code right now? Here are a few:

Python

Launch a Python sandbox here.

Java

Launch a Java sandbox here.

Swift

Launch a Swift sandbox here.

And of course, if you're a student, you can apply for the GitHub Student Developer Pack and get one year of Next Tech access completely free!

We hope that this free month of access will help you keep learning and building from home. Stay safe!

Best wishes from Next Tech.

3 Reasons Why the GitHub Student Developer Pack Is So Awesome

Saul Costa — Thu, 22 Aug 2019 14:05:38 +0000

Yesterday, Next Tech launched as part of GitHub's Student Developer Pack. I'm super excited to be a part of it, but man, the Pack is just an incredible resource for students. Totally something I wish I'd had when I was in school!

So here's a quick mind dump of why it's so awesome (IMO) and a few reasons you should definitely check it out if you're a student.

Reason #1: $45,000 of FREE stuff! 🤯

The Pack gets you access to almost $45,000 worth of resources!! I'm not 100% sure how they calculate this, but GitHub says it, so it must be true:

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

College was expensive even when I went long ago (in 2010...), and I know it's only gotten more so since then. So I think it's great that the Pack helps students out with this by giving them all these great resources, enabling them to build awesome software without the cost of tools standing in their way.

The Pack DOUBLED in size this school year, which is just incredible. There are now 41 awesome deals! I've covered a few of my favorites below, but you should definitely check them all out.

Reason #2: So many great deals! 😍

The Pack is really diverse. There are so many different things you can build with it! Here are a few of my favorite deals (other than Next Tech's, of course!):

DigitalOcean

I love DigitalOcean because they've done an excellent job of walking the line between a powerful cloud hosting platform and an easy to use tool. As someone who has also used Amazon Web Services, Google Cloud, and Microsoft Azure over the years, I've really come to appreciate simplicity in cloud offerings.

Services like AWS and the others can do a LOT more than DigitalOcean, but in reality, you don't need that right now! Heck, Next Tech could probably even run it's entire site on top of DigitalOcean, if we wanted to (right now we're on Google Cloud). So it's plenty powerful.

Heroku

I first used Heroku years ago when I started writing web apps. It's even simpler than DigitalOcean to get up your first app, so it's a great resource when you're first getting started and just want to get your ideas up there (into the cloud).

It is good to eventually transition to something like DigitalOcean in my opinion, because you'll get much more experience with running your own servers if you do. But for just getting up a project for a class or as a first web app, Heroku is great!

SendGrid

This is a tool we use at Next Tech for sending emails. It allows you to send a massive number of emails, which is really handy when doing something like sending confirmation emails to new users. If you just use a personal email for this, you'll eventually get rate limited, and need a tool like SendGrid to get around this.

You can also use SendGrid's email template designer right on their website, which makes your emails look professional without that much effort on your part. Once you're done, you send these emails using SendGrid's API, which makes it very flexible, and also gets you some great experience with APIs!

Sentry

Sentry will alert you when a user of your application gets an error, and then provide you with useful debugging information you can use to fix it. They also do useful grouping of errors which can help you see what the most important bugs are for you to focus on.

I haven't used Sentry before, but we use a very similar tool (Bugsnag) to monitor for errors in our application. When I first started building web apps, I didn't know much about error monitoring, but after starting to use it, you'll never stop.

As you can see above, the Pack gets you 500,000 events/month, where each "event" is an error being triggered. For what you build while in school, this should be more than enough!

Termius

Termius merges your SSH sessions across Linux, OS X, Windows, iOS, and Android. If you don't know already, SSH stands for "Secure Shell", and allows you to access your computer remotely using either a password or a private key (recommended).

I haven't used Termius yet (I just learned about it yesterday, when they got added to the Pack), but I plan on doing it ASAP. I use another tool to do something similar from my phone, but this looks like it may work much better!

.tech Domains

Last but not least, the fancy .tech domains. The Pack gets you one free .tech domain for one year. As the owner of next.tech, I may be a bit biased, but I think this deal is really cool.

Reason #3: The Pack is really well done 💎

GitHub works closely with the Pack members. This may not seem like that great of a reason, but having just gone through the onboarding process with them, I have learned a few things from working with the Pack team:

They really care about what they're doing. So as a student, you can rest assured that they have your best interests at heart!
They make sure that each new deal brings a lot of value to the Pack for students. This makes it well worth your time to get access to the Pack.
They work hard to ensure that each Pack offer makes it easy for students to redeem their offer.

How to Get the Pack 🚀

Getting started with the Pack is really easy. Just head here to get started! They'll walk you through a quick approval process, and then you can get started with redeeming your offers.

Next Tech's promotion 👩‍💻👨‍💻

Once you have your Pack, if you're interested in learning a new tech skill or want to write some code online, come grab your free year on Next Tech. All you have to do is sign up with GitHub.

Also...

What's your favorite deal? Let me know in the comments! As the CEO of an education startup, I'd love to see what most interests you as a student.

TTFN!

Free coding environments and interactive courses!

Saul Costa — Tue, 20 Aug 2019 16:56:20 +0000

Hello Dev.to readers! 👋

We have some exciting news to share with you: we’ve partnered with the GitHub Student Developer Pack to make it easier for students everywhere to learn programming and write your own programs!

What does this mean for you as a student? Well, students now get access to Next Tech’s course library and sandboxed computing environments for free for a whole year! Typically this would cost $228, but with our offer, you can save that money for a ☔ day (or a ☀️ one, for that matter!).

As former and current computing students ourselves, we know that setting up your computer for programming can be tough. It’s especially frustrating when you can see the solution to your homework or next project in your head, but your computer just isn’t working.

This is the exact problem Next Tech was founded to solve! Instead of having to do this set up yourself, you can launch a real programming environment in a couple of seconds and use it directly from your browser. 🤯

With these programming environments, you can learn programming, web development, data science, and more with our library of courses. Or, you can start from scratch and build an entire project using some coding sandboxes. All with no downloads, fast access from any computer anywhere, and now, free for you. 😊

Sound like fun? Head over to the GitHub Student Developer Pack page to claim yours, or if you already have the Pack, come check out Next Tech!

Build a Blackjack Command Line Game

Saul Costa — Tue, 23 Jul 2019 16:16:21 +0000

In this tutorial, we'll cover how to build a command line game for playing Blackjack using Python! You'll get to build the game from start to finish, and when you're done, you'll have a fully functioning game to play from the command line.

While building the game, we'll explore a few handy Python concepts, such as object-oriented programming using classes and how to manage a game loop. This tutorial is also extracted from an entire course on building a Blackjack game using a graphical user environment (GUI), which you can check out here if you're interested.

Sound fun? Let's do it!

What is Blackjack?

Blackjack is a gambling game that requires only a deck of cards. The goal of the game is to get as close as possible to a hand worth 21 points as the dealer flips over your cards – but go over and you're out!

In Blackjack, numbered cards (2 through 10) are worth their face value, picture cards (jack, queen, and king) are worth 10, and an ace is worth either 1 or 11 depending on your other cards. To start a hand, players place their bets and are dealt two cards face up. They can choose to "hit" (receive another card) or "stick" (stay with their current hand) as they attempt to get as close as possible to 21. If they chose to hit and go over 21, they "bust" and lose the hand (and the money they bet!).

Players face off against the dealer, who starts with one card face down and one face up. When all players have chosen to stick or have busted, the dealer then flips over their hidden card and either hits or sticks, their goal being to get a higher hand than any of the players.

If the dealer busts, they pay out the value of each player's wager to that player, provided that the player hasn't already busted. They also need to pay out if they don't get a higher hand than a player.

There are a lot of other rules (of course!) that you can read up on if you're interested, but the above is everything you need to know to build this game.

Okay, let's get started with some coding!

Installing Python

If you don't already have Python installed on your computer, you'll need to do so based on the instructions here. If you'd rather avoid that, you can grab an online coding sandbox with Python and other necessary libraries pre-installed here (sign in required).

Defining Classes

Before we begin coding our blackjack game, it's important we cover how we'll use object-oriented programming, since we will need to utilize classes for our game.

We will begin by defining the classes that will be used in order to separate out different aspects of the game of blackjack. We will model three of the components of the game:

Card: A basic playing card. The card belongs to a suit (hearts ♥, diamonds ♦, spades ♠, or clubs ♣) and is worth a certain value.
Deck: A collection of cards. The deck shrinks as cards are drawn and contains 52 unique cards.
Hand: Each player's assigned cards. A hand is what defines each player's score and thus who wins.

Let's begin with the simplest concept: the Card.

The `Card` class

The Card class will be the first class we define, as both of our other classes will need to use it. Create a Python file called blackjack.py, then add the following code:

import random

class Card:
    def __init__(self, suit, value):
        self.suit = suit
        self.value = value

    def __repr__(self):
        return " of ".join((self.value, self.suit))

The only import we will need for our game is the random module. This will allow us to shuffle our virtual deck of cards at the beginning of every game.

Our first class will be one representing the playing cards. Each card will have a suit (hearts, diamonds, spades, and clubs) and a value (ace through king). We define the __repr__ function in order to change how the card is displayed when we call print on it. Our function will return the value and the suit, for example, King of Spades. That's all we need to do for a Card!

Next up, we need to create a Deck of these Card classes.

The `Deck` class

The Deck will need to contain 52 unique cards and must be able to shuffle itself. It will also need to be able to deal cards and decrease in size as cards are removed. Create the Deck class in the blackjack.py file using the below code:

class Deck:
    def __init__(self):
        self.cards = [Card(s, v) for s in ["Spades", "Clubs", "Hearts",
                      "Diamonds"] for v in ["A", "2", "3", "4", "5", "6", 
                      "7", "8", "9", "10", "J", "Q", "K"]]

    def shuffle(self):
        if len(self.cards) > 1:
            random.shuffle(self.cards)

    def deal(self):
        if len(self.cards) > 1:
            return self.cards.pop(0)

When creating an instance of the Deck, we simply need to have a collection of every possible card. We achieve this by using a list comprehension containing lists of every suit and value. We pass each combination over to the initialization for our Card class to create 52 unique Card instances.

Our Deck will need to be able to be shuffled so that every game is different. We use the shuffle function in the random library to do this for us (how fitting). To avoid any potential errors, we will only shuffle a deck which still has two or more cards in it, since shuffling one or zero cards is pointless.

After shuffling, we will need to deal cards too. We utilize the pop function of a list (which is the data structure holding our cards) to return the top card and remove it from the deck so that it cannot be dealt again.

That's it for the Deck class! The final utility class to be created for our game to work is the Hand. All players have a hand of cards, and each hand is worth a numerical value based on the cards it contains.

The `Hand` class

A Hand class will need to contain cards just like the Deck class does. It will also be assigned a value by the rules of the game based on which cards it contains. Since the dealer's hand should only display one card, we also keep track of whether the Hand belongs to the dealer to accommodate this rule.

Start with the below to create the Hand class in the blackjack.py file:

class Hand:
    def __init__(self, dealer=False):
        self.dealer = dealer
        self.cards = []
        self.value = 0

    def add_card(self, card):
        self.cards.append(card)

Much like the Deck, a Hand will hold its cards as a list of Card instances. When adding a card to the hand, we simply add the Card instance to our cards list.

Within the Hand class, calculating the currently held cards value is where the rules of the game come into play the most:

    def calculate_value(self):
        self.value = 0
        has_ace = False
        for card in self.cards:
            if card.value.isnumeric():
                self.value += int(card.value)
            else:
                if card.value == "A":
                    has_ace = True
                    self.value += 11
                else:
                    self.value += 10

        if has_ace and self.value > 21:
            self.value -= 10

    def get_value(self):
        self.calculate_value()
        return self.value

You may note that the above code is already indented. This is intentional and done below too! This way, you don't need to perform the indents yourself and can focus on reading the instructions and code instead of chasing down whitespace errors.

In this code, we first initialize the value of the hand to 0 and assume the player does not have an ace (since this is a special case).

Then, we loop through the Card instances and try to add their value as a number to the player's total, using the following logic:

If the card's value is numerical, we add its value to the value of this hand (self.value).
If it is not numerical, we check to see whether the card is an ace. If it is, we add 11 to the hand's value and set the has_ace flag to True.
If it is not an ace, we simply add 10 to the value of the hand.

Once this is done, we check to see if there was an ace and the increase of 11 points brought the hand's value over 21. If so, we make the ace worth 1 point instead by subtracting 10 from the hand's value.

Now, we need some way for the game to display each hand's cards, so we use a simple function to print each card in the hand, and the value of the player's hand too. The dealer's first card is face down, so we print hidden instead:

    def display(self):
        if self.dealer:
            print("hidden")
            print(self.cards[1])
        else:
            for card in self.cards:
                print(card)
            print("Value:", self.get_value())

Now that we have all of our underlying data structures written, it's time for the main game loop!

The Game Loop

We will define the game's main loop within its play method, so that to start a game, you will simply need to create an instance of the Game class and call .play() on it:

class Game:
    def __init__(self):
        pass

    def play(self):
        playing = True

        while playing:
            self.deck = Deck()
            self.deck.shuffle()

            self.player_hand = Hand()
            self.dealer_hand = Hand(dealer=True)

            for i in range(2):
                self.player_hand.add_card(self.deck.deal())
                self.dealer_hand.add_card(self.deck.deal())

            print("Your hand is:")
            self.player_hand.display()
            print()
            print("Dealer's hand is:")
            self.dealer_hand.display()

The above code is pretty lengthy, so let's break it down:

We start off our loop with a Boolean (playing) which will be used to track whether or not we are still playing the game.
If we are, we need a shuffled Deck and two Hand instances—one for the dealer and one for the player.
We use the range function to deal two cards each to the player and the dealer. Our deal method will return a Card instance, which is passed to the add_card method of our Hand instances.
Finally, we display the hands to our player. We can use the display method on our Hand instances to print this to the screen.

This marks the end of the code that needs to run at the beginning of every new game. Now, we enter a loop that will run until a winner is decided. We again control this with a Boolean (game_over):

            game_over = False

            while not game_over:
                player_has_blackjack, dealer_has_blackjack = self.check_for_blackjack()

Before continuing, we first need to check for blackjack. If either player has been dealt an ace and a picture card, their hand will total 21, so they automatically win. Let's create the method to do this (under the play method):

    def check_for_blackjack(self):
        player = False
        dealer = False
        if self.player_hand.get_value() == 21:
            player = True
        if self.dealer_hand.get_value() == 21:
            dealer = True

        return player, dealer

We need to keep track of which player may have blackjack, so we will keep a Boolean for the player (player) and the dealer (dealer).

Next, go back to the while not game_over loop inside the play() method. We need to check whether either hand totals 21, which we will do using two if statements. If either has a hand value of 21, their Boolean is changed to True.

If either of the Booleans are True, then we have a winner, and will print the winner to the screen and continue, thus breaking us out of the game loop. To accomplish this, add the below directly underneath the player_has_blackjack, dealer_has_blackjack = self.check_for_blackjack() line of code:

                if player_has_blackjack or dealer_has_blackjack:
                    game_over = True
                    self.show_blackjack_results(
                        player_has_blackjack, dealer_has_blackjack)
                    continue

We must once again pause to create the method show_blackjack_results(), which will print the winner to the screen. We do this by adding the code below underneath the check_for_blackjack method:

    def show_blackjack_results(self, player_has_blackjack, dealer_has_blackjack):
        if player_has_blackjack and dealer_has_blackjack:
            print("Both players have blackjack! Draw!")

        elif player_has_blackjack:
            print("You have blackjack! You win!")

        elif dealer_has_blackjack:
            print("Dealer has blackjack! Dealer wins!")

If neither player had blackjack, the game loop will continue.

The player can now make a choice—whether or not to add more cards to their hand (hit) or submit their current hand (stick). To do this, add the below to the play method:

                choice = input("Please choose [Hit / Stick] ").lower()
                while choice not in ["h", "s", "hit", "stick"]:
                    choice = input("Please enter 'hit' or 'stick' (or H/S) ").lower()

We use the input function to collect a choice from the user. This will always return us a string containing the text the user typed into the command line.

Since we have a string, we can cast the user's input to lowercase using the lower function to avoid having to check combinations of upper case and lower case when parsing their reply.

If their input is not recognized, we will simply keep asking for it again until it is:

                if choice in ['hit', 'h']:
                    self.player_hand.add_card(self.deck.deal())
                    self.player_hand.display()

Should the player choose to hit, they will need to add an extra card to their hand. This is done in the same way as before with the deal() and add_card() methods.

Since their total has changed, we will now need to check whether they are over the allowed limit of 21. Let's define a method that does this now:

    def player_is_over(self):
        return self.player_hand.get_value() > 21

This method simply checks whether the player's hand value is over 21 and returns the information as a Boolean.

Now, back in the play method, add the following inside the if choice in ['hit', 'h'] block:

                    if self.player_is_over():
                        print("You have lost!")
                        game_over = True

If the player’s hand has a value over 21, they have lost, so the game loop needs to break and we set game_over to True (indicating that the dealer has won).

Okay, now let's handle when the player decides to stick with their hand. If they do this, it's time for their score to be compared with the dealer's. To do this, add the below aligned with the if choice in ['hit', 'h'] statement:

                else:
                    player_hand_value = self.player_hand.get_value()
                    dealer_hand_value = self.dealer_hand.get_value()

                    print("Final Results")
                    print("Your hand:", player_hand_value)
                    print("Dealer's hand:", dealer_hand_value)

                    if player_hand_value > dealer_hand_value:
                        print("You Win!")
                    elif player_hand_value == dealer_hand_value:
                        print("Tie!")
                    else:
                        print("Dealer Wins!")
                    game_over = True

We use the else statement here because we have already established that the user's answer was either hit or stick, and we have just checked hit. This means we will only get into this block when the user wants to stick.

The value of both the player's and the dealer's hand are printed to the screen to give the final results. We then compare the values of each hand to see which is higher.

If the player's hand is a higher value than the dealer's, we print You Win!. If the scores are equal, then we have a tie, so we print Tie!. Otherwise, the dealer must have a higher hand than the player, so we show Dealer wins!.

That completes the logic required for a user to play a single game. Now, let's make it possible for them to play another game by adding the following at the end of the play method, outside of the while loop:

            again = input("Play Again? [Y/N] ")
            while again.lower() not in ["y", "n"]:
                again = input("Please enter Y or N ")
            if again.lower() == "n":
                print("Thanks for playing!")
                playing = False
            else:
                game_over = False

We once again use the combination of lower and a while loop to ensure our answer is a y or n. If the player answers with n, we thank them for playing and set our playing Boolean to False, thus breaking us out of the main game loop and ending the program. If not, they must have answered y, so we set game_over to False and let our main loop run again. This will take us right back to the top at self.deck = Deck() to set up a brand new game.

Running the Game

We've completed the game! Now, it's time to run this code. To do this, we simply create an instance of the Game class at the end of the file and call the play() method:

if __name__ == "__main__":
    game = Game()
    game.play()

Now we have a game, give it a play. You can start the game by typing python3 blackjack.py into your command line (or pressing the blue "Run" button, if you're using the sandbox mentioned earlier).

You should see something like the following printed onto your screen:

workspace $ python3 blackjack.py
Your hand is:
A of Diamonds
5 of Clubs
Value: 16

Dealer's hand is:
hidden
A of Clubs
Please choose [Hit / Stick] H
A of Diamonds
5 of Clubs
10 of Hearts
Value: 16
Please choose [Hit / Stick] H
A of Diamonds
5 of Clubs
10 of Hearts
2 of Clubs
Value: 18
Please choose [Hit / Stick] S
Final Results
Your hand: 18
Dealer's hand: 16
You Win!
Play Again? [Y/N] N
Thanks for playing!

Wrapping Up

Congrats on working your way through this tutorial! In it, we covered how to build handy concepts like object-oriented programming, game flow design, and even the basics of Blackjack.

If you got stuck, the complete solution for this project can be found here. You can also launch an online coding sandbox with it preloaded here.

Two limitations of this game are that the dealer will never hit and there is no concept of betting. Feel free to add these features yourself if you'd like! Because a dealer is required to hit or stick at certain hand values, you can develop a program that mimic the dealer exactly.

You can also check out the full course behind this tutorial, if you'd like!

Launch VS Code in online computing environments

Saul Costa — Tue, 28 May 2019 21:26:40 +0000

I'm excited to share that Next Tech has released alpha support for Visual Studio Code!

VS Code is hands-down one of (if not) the best code editors out there. It's trounced others (like Sublime and Atom) in popularity in recent years, thanks to the incredible features Microsoft has added and the vast library of extensions tens of thousands of developers have created.

Installing VS Code is pretty straightforward and you can do it yourself on your computer if you'd like. However, we've found that our hosted environments for Python, Node, Go, Haskell, and many other programming languages make it super easy to get started with a new programming project in just a few seconds.

So we thought, wouldn't it be great if you could use these environments… and VS Code?!

Well now, you can. This includes the ability to install extensions, change your settings, debug programs, push to GitHub, deploy to Azure, and much more.

This guide walks you through how to get started with VS Code on Next Tech. If you just want to jump into a sandbox with VS Code, click here. In a few seconds you'll have VS Code running in your browser:

Or, read on for the details!

Why VS Code?

Over the years we've received many requests for innovative features like code collaboration, debuggers, version control integration, and much more, but our focus is increasingly on our infrastructure offerings. As such, we see VS Code as being able to address a number of these requests as we continue to develop innovative infrastructure offerings.

VS Code is also the most popular code editor by far. Here's Stack Overflow's 2019 developer survey results for the most popular development environments:

This is also coming at a cost to other editors. Here's the Google Trends data for VS Code (blue) versus Sublime (red) and Atom (yellow):

So we feel that our investment into integrating VS Code will be well worth it as we'll be able to provide a well-loved tool inside our infrastructure.

This feature is currently in a very early alpha state (current limitations are documented here). However, in the coming months we'll be rolling out a more tightly integrated version and many other related improvements.

Here's what's currently supported:

Intelligent code completion (IntelliSense).
Powerful debugging functionality.
Numerous different ways to configure your interface (multiple tabs, zen mode, etc.).
Integrated terminals.
Multiple themes.
VS Code's command line interface.
…and many other extensions you can install.

Very soon, we'll also be adding support for:

An integrated web browser.
VS Code's Live Share feature, which allows you to collaborate with others in real-time.

For now, I hope you'll take a look and share your feedback!

Getting Started

To get started, head over to the sandbox launchpad. Once you're there, pick the language you'd like to use (this guide uses Golang), then check Use Visual Studio Code, as shown below:

You'll be shown a dialog that contains an explanation of the current limitations of this feature (also detailed at the end of this page). Just click the Sounds fun, let's go! button and your sandbox will load with the VS Code interface:

You may notice that VS Code is just another tab type in the sandbox interface. If you click the + to create a new tab, you may notice that some options are now hidden:

Eventually these will all be hidden as we integrate them directly inside of the VS Code interface.

For the best experience, you can click the square in the top right corner of the VS Code interface to make VS Code full screen:

To get started, you can click File, then New File:

(note that the Ctrl+N will not work in the browser)

Save your file as main.go, then put this code in it:

Now, head over to the extensions marketplace and install the Go extension:

(you may need to press Ctrl+Shift+P, type “reload”, then select Developer: Reload Window to get things working correctly)

You'll be prompted in the bottom right to install several packages. Go for it!

You can try typing b in the code editor to see the intelligent autocomplete kicking in. Here, it sees that b is actually an array with 5 ints in it:

You can run code using the software normally installed in your sandbox. To run this file, click Terminal, then New Terminal:

Then you can use the already installed go program from your sandbox:

And there you have it! You've just used VS Code in the cloud to write a Go program.

Feedback

If you try this new feature, I'd love to hear what you think. Feel free to respond to this post or submit a ticket here.

Thanks for reading!

Shout-out

This integration uses an adapted version of this awesome open source project by Coder!

Learn Python Interactively with These 5 Tutorials

Saul Costa — Thu, 23 May 2019 22:13:23 +0000

This post walks you through how to launch an online coding environment and then covers 5 tutorials for learning various Python skills. You can use your sandbox alongside these tutorials so you can learn by doing as you read!

Let's get started!

Setup

To get started, launch a Python sandbox on Next Tech by clicking here.

Then pick one of the sites from the list below, for example, Google's Python Class.

That link skips the install section of the class entirely, since your sandbox already has Python installed!

This tutorial says you can use an interactive command line (launch by typing python into your sandbox terminal) OR a file with Python code in it. To do the latter, just create a file in your sandbox (e.g. main.py) and put your code in there. Click the blue Run button to execute your program.

As you read through the tutorial, you can click the copy icon in the top right of each code box to copy the code to your clipboard. Then, back in your sandbox, paste the code into your editor or command line.

While the other tutorials may differ slightly, they all follow this general idea: take the code in the tutorial, and run it inside your sandbox. Let's take a look at all the tutorials!

#1: Google's Python Class

Google's Python Class is free and designed for people with some programming experience (i.e. know what a "variable" or "if statement" is) and want to learn Python. The class is actually used inside Google to introduce people to Python!

The class includes:

Written tutorials
Videos
Code exercises

The class starts with basic Python concepts like strings and lists, working towards full programs that cover text files, processes, and http connections.

#2: The Official Python Tutorial

The Official Python Tutorial is provided by the Python Software Foundation that is the creator of the Python programming language.

While the tutorial claims to not attempt to cover every single feature, it is extremely in-depth, and covers the following topics:

An introduction to Python
Program control flow
Data structures
Modules
Input and output
Errors and exceptions
Classes
Some of the Python standard libraries

After reading it, you will be able to read and write Python modules and programs and will be ready to learn more about the various Python library modules described in The Python Standard Library.

#3: Official Flask Tutorial

Flask is a Python microframework used for creating web applications. Their official tutorial covers:

Project layout
Application setup
Database integration
Blueprints, views, and templates
Static files

...and quite a bit more!

The tutorial walks you through creating a basic blog application called Flaskr. Once completed, users of the application will be able to register, log in, create posts, and edit or delete their own posts.

You should have at least some basic Python knowledge to get started with this tutorial.

#4: Introduction to Python Generators

In Python, generators are functions that can be stopped and started on demand, returning an object that can be iterated over later. Unlike lists, they are "lazy" and produce (or "generate") items one at a time and only when necessary. This makes them much more memory efficient when dealing with large amounts of data.

This tutorial details how to create generators and expressions and when and why you might use them.

#5: Stripe's Python Integration

Stripe is the leading payment processing platform and makes it easy for developers to integrate payment processing into their application. Stripe's official documentation walks you through how to use their API using Python. It includes:

Using a REST API
API authentication
API error handling
API pagination
All Stripe API endpoints

While this isn't a proper tutorial, it does a great job of walking you through how to explore the Stripe API using Python. Be sure to select Python when you load the page!

Summary

In this post we've covered 5 tutorials and guides you can use with a Python sandbox. I hope it's been useful! If you have ideas for other tutorials to include, just drop us a note below!

Using Python's Django framework in the cloud

Saul Costa — Tue, 21 May 2019 17:21:57 +0000

Django is a Python framework for building web apps. Their website describes it like so:

Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of Web development, so you can focus on writing your app without needing to reinvent the wheel. It's free and open source.

In this post, we'll cover how to use the Next Sandbox to get started with Django without downloading anything! We'll walk through how you can launch a Python sandbox and then install Django in it.

First, click here to launch a Python sandbox (you'll need to create a free Next Tech account if you haven't already).

Once your sandbox has loaded, run the following commands in your sandbox's terminal to install Django:

sudo apt update
sudo apt install -y python3-django

Then, create a new Django project:

django-admin startproject project .

Now you can run the initial Django migrations:

python3 manage.py migrate

Migrations in Django are explained in detail here.

To start the Django web server, run the following in your terminal:

python3 manage.py runserver 0.0.0.0:8000

Note the use of the 0.0.0.0:8000. This is required to allow remote connections, which you will technically be making to your sandbox.

You'll also need to make some changes to the project/settings.py file. First, replace the contents of the MIDDLEWARE list with this:

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware'
]

This removes an option added by default that prevents your webpage from being embedded, which it needs to be so the in-sandbox web browser can load it.

Then, you need add this line to the file:

ALLOWED_HOSTS = ['*']

This will allow any host to connect so the domain your sandbox is running on will be able to.

This part of your file should now look something like this:

Okay, all set! Now, click the + and select a browser, then enter localhost:8000 in the URL bar. You'll be shown this:

Great work! You can now continue to explore Django. I recommend reading through the Django Quick Start guide, which covers some of what we have in this post, and much more!

Have a question or comment? Drop us a note below!

Getting Started with the Next Sandbox

Saul Costa — Wed, 08 May 2019 16:02:01 +0000

I’m excited to announce the release of Next Tech’s newest product: Next Sandbox!

The Next Sandbox provides access to real-world computing environments in 2 seconds directly from your browser. Rather than installing the programming language or software you want to use on your computer, you can just click a button and access that language or software right away using a browser-based development tool.

We built Sandbox to solve two key problems we experienced ourselves as developers almost every day:

Installing software is haaaaaaard. Even experienced developers can struggle with this and it’s something that can get in the way of trying out new ideas. It’s nice to have something work out of the box so you can focus on innovating.
When you DO install software on your computer yourself — especially if you just want to test it — it can quickly clutter your environment. Maybe you want to try the newest version of Java, but installing it on your computer could cause issues with your current version.

The Next Sandbox addresses these issues by shifting the burden of installing software off of you and onto us. But that’s okay, we’ve been doing this for years! The Next Sandbox is based on the same infrastructure and interface that powers our product for teaching and learning tech skills, which is used by leading educational companies all around the world. In fact, the CS50 program at Harvard actually built their own sandbox atop our infrastructure!

Here’s what a sandbox for the Python programming language looks like when you first launch it:‌

In this getting started guide we’ll cover how to launch your first sandbox and some of the exciting things you can do with it.

Let’s dive right in!

First things first

To start, I recommend using this link to sign up for Next Tech if you haven’t already:

nt.dev?ref=ce315f8c

Next Tech uses minute-based pricing, where you pay 1 cent per minute you spend on the page with a sandbox open. You typically get $10 in free credits when you sign up (that’s 1,000 minutes of coding!), but if you use that link, you’ll get $15!

The account for that referral link also receives $5 each time a referred user activates their account. If you sign up with that link, you’ll be entered to win access said account, as we’ll be randomly selecting a referred user to win once the account value hits $250!

If you have any questions about our pricing, please don’t hesitate to comment directly on this post.

Okay, back to it. Once you’ve created a Next Tech account, you have two options for launching a sandbox:

Use a nt.dev URL, like nt.dev/python. This will instantly get you into a fresh Python sandbox.
Use the launchpad to select the environment you’d like. This page contains a number of details about each environment.

Initially your sandbox will display a directory tree viewer, code editor, and terminal. To add some code, just click the + icon or the ... next to your working directory, then New File:

You’ll be shown an overlay like this:

Go ahead and create a file named main.py. Don't worry about the tabs at the bottom yet — we'll cover those soon!

Or — if you want to get fancy — you can type touch main.py in your terminal. The Linux touch command will create a new file with the specified name.

Once you’ve created a file, it will be saved to your working directory (shown in the file tree as ~/workspace, the absolute path for which is /home/nt-user/workspace). So the full path for this file is /home/nt-user/workspace/main.py.

You can put any Python code you’d like here, but in case you don’t have some handy, here’s a quick calculator to get you started:

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    return x / y

if __name__ == '__main__':
    x = int(input('Please enter a number: '))
    y = int(input('Please enter another number: '))
    print(add(x, y))
    print(subtract(x, y))
    print(multiply(x, y))
    print(divide(x, y))

You can run this file from the terminal however you’d like, for example, python3 main.py. You'll be shown the output of the program, for example:

workspace $ python3 main.py
Please enter a number: 123
Please enter another number: 456
579
-333
56088
0.26973684210526316

‌The terminal connects you to an actual computing environment. Go ahead, give ls -l / a try in the terminal, where you'll see a full operating system directory structure! You also have full admin access (sudo), so you can alter any part of the filesystem you'd like.

You can read about more ways to use a sandbox here!

Other computing environments

There are sandboxes for a multitude of other environments, including:

Common programming languages like Java, C++, Swift, and C#
Web development technologies like HTML, CSS, JavaScript, Ruby on Rails, and PHP
Data science frameworks for Python and R
Databases like PostgreSQL and MySQL
Specialty languages like Elm, Haskell, Golang, and Rust‌

You can find a complete list of the environments here.

Each sandbox comes with certain programs preinstalled. If you launched the Python sandbox, you can run ipython in the terminal to jump into that nifty piece of software. You can also install new software, for example:

sudo apt install -y gnome-calculator

Each sandbox is given access to 256MB of free disk space and can use up to 2GB of RAM. It also has access to up to 4 CPU’s worth of processing power.

Tab-based interface

After you’ve run the above command, open a Desktop tab by clicking the +and selecting Desktop, then run gnome-calculator in the terminal . You'll see this:

This is a real calculator running in your sandbox!

Pretty slick, right?

You probably noticed by now that there are a multitude of other tabs you can select from. Here’s a quick list of the others:

Terminal tabs give you access to a new terminal, which makes it easy to run multiple programs or commands concurrently.
Browser tabs load a web browser you can use to connect to web accessible services running in your sandbox.
Jupyter tabs loads an actual Jupyter Notebook for you to work in, which is great for data science or machine learning.
Skulpt is a JavaScript implementation of some of the basic features of Python, oftentimes used with the turtle and processing Python libraries.

Sharing your work

You’ve probably already seen the Share button at the top right of the page! If you send a share URL to someone, they’ll get a copy of your sandbox as it stands when they click the URL. Note that you will not be billed for their usage.

Here’s my share URL for the project I used to take the screenshots for this post:

next.tech/projects/0295f1cee35f/share

If you click that, you’ll be taken straight to a Python sandbox with the calculator code in it. Note that it won’t have the gnome-calculator installed because (currently) sandboxes do not persist newly installed software, so you'll have to install that yourself if you'd like to try it.

There are a number of other pre-made sandboxes ready for launch here!

Downloading your work

The files you create (and the tabs) are saved automatically as you work in your sandbox. However, sometimes you may want to save them to your local machine, for example if you’ve tested a proof-of-concept and now want to continue to work on it as part of your normal development process.

To do this, just click the settings gear in the bottom left of the page, then choose Download.

Summary

Whew, that was a lot to cover! Let’s recap. Above, we explored:

Launching a computing environment for Python in a few seconds (especially if you used the nt.dev URL)
Writing a basic calculator in Python
The various interface elements available to you in a sandbox
Installing software in a sandbox (the gnome-calculator)
Opening an actual desktop environment and using that software
Downloading your work for use in your local development environment

This has been just a quick guide to get you started. If you’d like, you can explore the rest of the Sandbox documentation here to learn more about what you can do in a sandbox!

If you have any feedback you’d like to share, please don’t hesitate respond to this post. We’d love to hear from you!

New Year, New Interface!

Saul Costa — Sun, 20 Jan 2019 21:56:56 +0000

At Next Tech we’re are incredibly excited to announce the release of our tab-based interface! This enables any interface component (e.g. a web browser or terminal) to be placed in any section (or “pane”) of the interface. This means a terminal can be loaded next to a code file, a full GUI viewer can be alongside a SQL display, and so forth.

Previously, each pane could only support a single component. So if you wanted a code editor, terminal, and web browser, you needed a three pane layout. This worked well for introductory use cases but as we’ve pushed further into serving developers as well as beginners with learning materials, we found this approach to be a major limitation. For example, when teaching a web framework, a terminal is only required to run a command or two. So having to keep it on the screen taking space away from a code editor and web browser led to an unnecessarily squashed layout.

Here’s what that might have looked like before:

And here’s what it would look like now:

Note that the GUI and terminal tabs are now located side-by-side in a two pane layout versus requiring a three pane layout to accommodate the identical use case.

Now the large number of interface elements we support and the new ones we’re creating can be mixed and matched in hundreds of ways. The option to open a new tab can also be left to the learner versus pre-configured.

Currently, we support the following tab types:

Editable code and text files
Terminals with or without root access
Web browsers for any port
GUI displays with X support
SQL result tables
Python graphic displays for Skulpt programs
Media files such as images and videos

We believe wholeheartedly that providing a traditional IDE loaded with menus does a disservice to learners and anyone working on a project. At the same time, a box that simply runs code isn’t useful either. So this interface, like others we have built, was designed carefully, one piece at a time to ensure it is powerful yet simple for anyone to use.

We’ve already put this interface to good use with a number of our courses on programming, web development, database design, and machine learning. We’re now offering a $9 a month subscription to access our courses, and you can get started free for a week!

If you’d like to learn more about how to build your own courses with this interface atop Next Tech, we’d love to hear from you.

New Course: Database Fundamentals

Saul Costa — Wed, 03 Oct 2018 17:01:24 +0000

We just released Database Fundamentals, the latest interactive course on Next XYZ!

This course will take you through the foundational concepts of databases and SQL (Structured Query Language). Plus, it’s free!

You’ll help Codey ― the Next XYZ coding bot ― design, build, and maintain a database for a construction company, as well as answer important questions using data.

Along the way, you’ll learn how to:

Create databases and modify their schemas
Add, update, and delete data
Query records in a database using SQL
Join, filter, group, and sort results
Ensure your database is normalized

You don’t need to have worked with databases before or have any coding experience to take this course.

Want to take a look? You can find it here.

An Interview with Andrew Sverdrup

Saul Costa — Mon, 02 Jul 2018 18:32:58 +0000

“The ability to provide something of value to many people is the driving force behind my love of technology.”
― Andrew Sverdrup

Hey Andrew, excited to be sitting down with you and doing this interview! To get started, mind telling me a little about yourself?

Sure thing! I am a recent college grad and am excited to put the programming knowledge I have learned to use. My degree is in Software Engineering from Embry-Riddle in Arizona. And I recently joined Next XYZ as their first full time software engineer!

I like to stay active by working out and playing basketball. I love learning and trying out new programming languages to see what they’re like. I learn by doing so I enjoy finding new languages and libraries and seeing what I can build with them.

Awesome. So tell me about your course!

The Python OpenWeatherMap (PyOWM) course teaches you how to use the OpenWeatherMap API with Python. OpenWeatherMap is a powerful API that lets you retrieve weather data for virtually any location in the world, and they have a generous free tier to get you started! The PyOWM library allows you to easily use the OpenWeatherMap API with Python.

The first half of the course covers the basics that you need to know to get weather data using PyOWM, including the temperature, wind speed, and humidity. The second half is my favorite though. That’s where we use the temperature data to create a graphical user interface (GUI) to display the temperature forecast! And finally at the end you’re challenged to modify that GUI to display the humidity forecast.

What made you decide to build this course?

I decided to build the course because I’ve learned many cool things while programming and I want to share them with others so they can learn too! Programming provides seemingly endless possibilities to create both fun and useful projects. Next XYZ allows me to easily share what I’ve learned with others and I look forward to hearing what people think of the course!

What got you interested in technology in the first place?

I’ve been fascinated by computers ever since I was a kid. It takes a lot of money to build things such as houses, but with programming you can create something valuable with very few resources. All you need is a computer, some programming skills, and some ideas! The ability to provide something of value to many people is the driving force behind my love of technology.

Do you have any ideas for future courses you might build?

I love sharing what I’ve learned with other people so they can see all the cool things that can be done with programming. I’m always exploring new languages and libraries and I will be creating more courses for some of my favorites, so stay tuned!

Where can readers find your course?

The course is published on Next XYZ here. Give it a try and let me know what you think!

You can find Andrew on Twitter.

CS50

Saul Costa — Mon, 25 Jun 2018 16:52:39 +0000

By Saul Costa

After a long day at SIGCSE 2018 this past February, I arrived back at my hotel room ready to wind down for the night. Working my way through an overflowing inbox, one email in particular from a Harvard University address caught my eye. And not just any Harvard address. It was an email from Dr. David J. Malan, the instructor for Harvard’s CS50 course, one of the most influential courses in computer science education.

Sleep would have to wait. After a few quick emails, David and I met for a late-night chat over iced tea and juice. By the end of the meeting, it was clear that an exciting opportunity was at hand.

CS50 is one of the most influential courses in computer science education and an icon in the field. The course is delivered with just the right mix of novelty and difficulty, which results in an engaging and valuable experience for its students. It’s no surprise that has become the largest course at Harvard, with over 600 students enrolled on campus and more than a million online. While CS50 provides an introduction to a range of concepts including abstraction, algorithms, and security, David strives to make the whole course an experience that students can look back on fondly, enabling them to explore areas beyond their comfort zone and hopefully fall in love with a new field of study.

At Codevolve, we believe that delivering opportunities to learn tech skills via an easy-to-use development environment removes the barriers that can derail a student when they’re just getting started. To execute on this core belief, we’ve built a platform that allows students to gain hands-on experience with technical skills like programming, web development, database management, and data science. We’ve already partnered with leading education companies around the world to power learning experiences for their students.

With Codevolve’s focus on building great tools for learning tech skills and CS50’s dedication to producing top-of-the-line learning materials, it was immediately apparent that both teams working together would have an incredibly positive impact on the students of CS50. That collaboration is now underway, and we’re already seeing excellent results!

Since SIGCSE, CS50 has leveraged our technology to develop sandbox.cs50.io, where students and teachers can quickly spin up an online, real-world coding environment preloaded with support for various languages like C, C++, HTML, Java, Python, and SQL. Users can set the environment to use any combination of text editor, terminal, web browser, or full GUI via an interface developed by CS50. Each sandbox has no preloaded learning content and instead provides value by allowing users to open environments in seconds so they can experiment with new ideas and concepts.

One of the great features of the CS50 sandbox is the ability to share a link that clones the current environment. Using this feature, an instructor can write a program in the sandbox during a class to show students a new concept and then share the link so they can easily pick up exploring where the instructor left off. Or a struggling student can copy their program into a sandbox environment and share that with a teaching fellow for feedback. No doubt, a multitude of other use cases will emerge in the coming semesters!

Backing each sandbox is a custom image that contains everything CS50 needs, from the languages they teach to custom tools that they have built. Codevolve hosts this specialized image and backs it with our “smart-scaler” to ensure that each sandbox session is provided a fresh environment in seconds (2.13 on average, as of this writing). While we have used these tools internally for years, this is the first time we have hosted a completely custom image for a partner. We foresee doing much more of this in the future as it opens up many exciting opportunities to form new partnerships!

CS50 has already been an invaluable source of feedback for us. Until now we have primarily partnered with learning companies, which adds a layer between us and their learners, who are the people using our product every day. Over the course of SIGCSE, I met with the CS50 team multiple times (as well as a couple of times all over the country since!) to discuss what worked, what didn’t, and what needed polishing. This feedback from one of the most experienced teams working on computer science education helped us map out numerous future improvements to our product, many of which we have already implemented.

In the coming months, CS50 plans to build lessons using API endpoints that we added per their request that let them remotely run their custom test suite (check50) to test student code. They’ll also use a git-centric structure for hosting their content, allowing them to create highly customized lessons very quickly without having to train their staff on our authoring tool. Internally we have always seen this as a logical next step for our product, and it is exciting to see such a talented group beginning to bring this vision to life before we’ve had the chance to build it ourselves!

Even though they’ve logged 90% of our recent feature requests, working with David and his team at CS50 has already been an incredible experience. They’ve pushed the boundaries of our product and already built out a great tool on top of it. We can’t wait to see what they come up with next!

In the meantime, want to learn more about CS50? You can take it for free at cs50.edx.org!

Originally published on Medium here.

Forem: Saul Costa

Free coding courses through May!

Python

Java

Swift

3 Reasons Why the GitHub Student Developer Pack Is So Awesome

Reason #1: $45,000 of FREE stuff! 🤯

Reason #2: So many great deals! 😍

DigitalOcean

Heroku

SendGrid

Sentry

Termius

.tech Domains

Reason #3: The Pack is really well done 💎

How to Get the Pack 🚀

Next Tech's promotion 👩‍💻👨‍💻

Also...

Free coding environments and interactive courses!

Build a Blackjack Command Line Game

What is Blackjack?

Installing Python

Defining Classes

The Card class

The Deck class

The Hand class

The Game Loop

Running the Game

Wrapping Up

Launch VS Code in online computing environments

Why VS Code?

Here's what's currently supported:

Very soon, we'll also be adding support for:

Getting Started

Feedback

Shout-out

Learn Python Interactively with These 5 Tutorials

Setup

#1: Google's Python Class

#2: The Official Python Tutorial

#3: Official Flask Tutorial

#4: Introduction to Python Generators

#5: Stripe's Python Integration

Summary

Using Python's Django framework in the cloud

Getting Started with the Next Sandbox

First things first

Other computing environments

Tab-based interface

Sharing your work

Downloading your work

Summary

New Year, New Interface!

New Course: Database Fundamentals

An Interview with Andrew Sverdrup

CS50

The `Card` class

The `Deck` class

The `Hand` class