Our mission at Next Tech is to make technology education accessible for everyone. While this has always been our goal, it was not something our product truly delivered on until recently, when we made an enormous investment into improving the accessibility of our product for users with disabilities. In this post we talk about the challenges we faced improving the accessibility of our web-based development interface, including specific techniques that we hope will be useful for others striving to do the same. We also discuss how this commitment to product accessibility naturally extends throughout our company and the positive impact that stemmed from this.

Let us start with a brief story. Starting in 2019, we increasingly heard the word “accessibility” from our customers. It quickly became clear that ensuring products were accessible for users with disabilities was something that students, instructors, and education institutions alike were thinking about more than ever. Seemingly all at once, education companies around the world heard the calls for increased accessibility and began to respond.

Next Tech did the same. Over the last half of 2019 and the start of 2020, we have launched an engineering initiative dedicated to addressing the problems faced by users with disabilities who are learning to code. After thoroughly researching the challenges presented by web-based products, we educated ourselves on the practical solutions to these problems. At the highest level, the goal of making accessible software is to ensure that it is perceivable, operable, and understandable by all. There are many considerations and methods that make this possible, but the most important thing is to start. Providing an accessible product requires ongoing investment, so the sooner you can begin releasing improvements, the better.

Our first steps were to assess the visual choices we had made in the past. We identified and fixed several issues throughout our product to make it easier to use for those with limited vision, for example, making colors easier to see by improving their contrast and increasing font sizes that were too small. This, like many accessibility improvements, benefits all of our users — even those without disabilities — by making the product easier for everyone to see.

After making some of those visual changes, we tackled keyboard usability. This is something critical for people who are visually impaired, as well as people with limited dexterity that leaves them unable to use a mouse or similar pointing device. It is also something that many advanced users, such as software developers, expect from a software development interface.

This is where we faced our biggest challenge. Because our product contains a full-featured code editor, we needed to ensure users could use their keyboard’s Tab key to navigate through our interface when needed while still being able to use Tab when writing code in the editor. After much internal discussion, we found a solution. By “wrapping” the code editor in an overlay with a message that informs anyone using a keyboard that they can “enter” and “exit” the component using a certain key combination. Once they have “entered” the editor they are able to type and use the keyboard as they would in a standalone application. Once finished they can use an “exit” key combination to resume navigating the page as before. We have found this solution to provide a seamless experience without affecting those using a mouse or similar input.

Another major challenge we faced was updating our product to be more usable with screen readers. Screen readers allow a visually impaired user to interact with modern applications by reading out the current state of an application or website and enabling them to interact with it accordingly. This is a challenge that the screen reader handles, but to function effectively it depends on the website being programmed in a specific way. The screen reader can expose the structure and state of an application to the user, but only if the website’s code is assembled correctly. This means that visual information (e.g., something that looks like a button or a footer) is not useful to screen readers. The button and footer must be explicitly labeled so the screen reader can convey that information to the user in a useful way. This also includes the state of an application, such as a menu being open or closed or a toggle being on or off.

Making these changes was quite a daunting task. Historically, much of our application was designed around making it “look right”, leaving a lot of room for ambiguous design choices. Since screen readers cannot handle ambiguity, we had to put some serious thought into some elements of our website. Understanding the expected interaction, what information needs to be conveyed, and how the application should respond were all factors behind our decisions. The strict requirements to ensure screen reader support has required us to be more deliberate in how we develop new user experiences, resulting in dozens of changes that make the product more consistent and usable for everyone.

We are thrilled with the improvements we have made to the accessibility of our product. But completing them resulted in an unexpected yet positive change: it helped us grow as a company. We have changed our mission statement to “making technology education accessible for everyone” to explicitly encompass our new focus on accessibility in all forms. Accessibility as an idea quickly spread to all levels of the company and became a lens through which we now view every new product, content, and growth initiatives.

As education continues to move online — an initiative that started years ago and has now been accelerated by COVID-19 — accessibility has become excruciatingly important. Where an instructor could previously help a student in person, there is now only a ZOOM call that presents nearly insurmountable challenges. Now, more than ever, making education products accessible is a challenge well worth the effort. We look forward to continuing to work with our customers in the years to come to ensure our product continues to make technology education accessible for everyone.

We have come a long way, but this is still the start of a journey for us. Follow us on Facebook or Twitter to stay in touch as we continue to work on making our product and technology education accessible for everyone.

A VPAT is available upon request. Please email hello@next.tech.

Next Tech’s Commitment to Accessibility was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

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:

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:

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:

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:

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:

1. If the card’s value is numerical, we add its value to the value of this hand (self.value).
2. 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.
3. 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:

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:

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):

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):

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 ifstatements. 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:

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:

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 playmethod:

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 lowerfunction 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:

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:

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 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:

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:

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_overto 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:

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:

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!

Build a Blackjack Command Line Game was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

React is one of the most popular web frameworks out there. It has been growing steadily in popularity for years, passing Angular for the first time in the 2019 Stack Overflow developer survey.

This post will show you how to create your own React website in just a few minutes. If you’re interested in learning more after completing this tutorial, checkout the Beginning React course I just created on Next Tech to further improve your React skills.

For now, let’s dive right into building a website with React!

Prerequisites

To complete these steps you’ll need to have the Node Package Manager (npm) installed. If you don’t have it installed yet, head on over to https://www.npmjs.com/get-npm to download and install npm.

This will also install npx which we'll use to run create-react-app.

Create React App

Create React App is an excellent way to quickly get a React website up and running. Create React App was created by Facebook (the same company that created React!). In their docs, they describe it as:

Create React App is an officially supported way to create single-page React applications. It offers a modern build setup with no configuration.

Knowing that Create React App is supported by the creators of React is a huge plus. Let’s use it to get started with our website!

Run the following command to create your site:

npx create-react-app hello-react

Note that it may take a couple minutes for this command to complete.

Viewing the React website

Next, run the following commands to start the React development server:

cd hello-react
npm start

At this point a browser tab should open showing your React site. If it doesn’t, visit http://localhost:3000 in your favorite browser to see your React site!

Updating the site

Now, let’s make a change to update the site. Open the hello-react/src/App.js file, then replace the line:

Edit <code>src/App.js</code> and save to reload.

with:

My first React website!

If you open the web page again you’ll see that it updated without you having to refresh the page! Live reloading is one of the awesome features that Create React App configures for you.

Creating a React Component

Next, we’ll create a new React component. First, create a folder in the src folder named components. Then create a file called HomepageImage.js in the src/components folder. This file will hold our new homepage image component.

We’ll create this component by adding the following code to the HomepageImage.js file:

Then, in App.js, replace

<img src={logo} className=”App-logo” alt=”logo” />

with

<HomepageImage />

We also need to import the component at the top of App.js by adding the following code to the top of the file:

import HomepageImage from './components/HomepageImage'

Since we removed the image of the React logo, you can then remove this import for the logo as well:

import logo from './logo.svg';

The final App.js file should look like this:

Now, open http://localhost:3000 again in your browser. If everything is working, you should see the following page:

Congratulations on creating your first website using React 🎉!

Next steps

This tutorial was a quick introduction to creating web pages with React. If you want to gain a better understanding of React so you can build awesome sites using it, checkout the course I just released that teaches React!

Have you built a site with React? Feel free to share your URL or a link to your project on GitHub in the comments below to show it off!

Thanks for reading,

Andrew, Software Engineer @ Next Tech

Special thanks to Maarten van den Heuvel for taking the photo of the Golden Gate Bridge used in this post!

Building your first React website was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

Object-oriented programming (OOP) is a programming paradigm organized around objects. At a high level, OOP is all about being able to structure code so that its functionality can be shared throughout the application. If done properly, OOP can lead to very elegantly written programs that have minimal code duplication.

This is opposed to procedural programming (PP), in which you build programs in sequential order and call methods when you want shared behavior between pages in the application. Common procedural programming languages include C and Go.

In this tutorial, you’ll learn the fundamental concepts of OOP for Ruby, an object-oriented programming language wherein everything is an object. We will be using Ruby since one of its defining attributes — in addition to its elegant syntax and readability — is how it implements OOP techniques. This makes it a great language to start learning OOP with.

We will cover:

• Creating classes
• Instantiating objects
• Initializing arguments
• Working with inheritance, and
• Private and public methods.

In learning these concepts, we will build out our own application: an API connector that communicates dynamically with an application that sends a text message. This will include walking through how to leverage concepts such as inheritance and object instantiation to make our code more scalable and reusable!

This brief tutorial is adapted from Next Tech’s Introduction to Ruby course, which includes an in-browser sandboxed environment and auto-checked interactive tasks to complete.

You can follow along with the code snippets in this tutorial using Next Tech’s sandbox which already has Ruby pre-installed. If you chose to use your own IDE, make sure Ruby is installed by following the instructions on the installation page.

Creating Classes

Before we begin, let’s define what an object is. At its core, an object is a self-contained piece of code that contains data (“attributes”) and behavior (“methods”) and can communicate with other objects. Objects of the same type are created from classes, which act as blueprints that define properties and behavior.

Creating a class in Ruby is fairly easy. To define a class, simply type the class word followed by the name of the class, and end it with the end word. Anything contained between class and end belongs to this class.

Class names in Ruby have a very specific style requirement. They need to start with a letter and if they represent multiple words, each new word needs also to be an uppercase letter — i.e. “CamelCase”.

We’ll start by creating a class called ApiConnector:

Classes in Ruby can store both data and methods. In many traditional OOP languages such as Java, you need to create two methods for each data element you want to be included in the class. One method, the setter, sets the value in the class. The other method, the getter, allows you to retrieve the value.

The process of creating setter and getter methods for every data attribute can be tiresome and leads to incredibly long class definitions. Thankfully Ruby has a set of tools called attribute accessors.

Let’s implement some setters and getters for some new data elements for our class. Since it’s an API connector, it would make sense to have data elements such as title, description, and url. We can add these elements with the following code:

When you merely create a class, it doesn’t do anything — it is simply a definition. In order to work with the class, we need to create an instance of it…we’ll cover that next!

Instantiation

To understand what instantiation is, let’s consider a real-world analogy. Let’s imagine that you’re building a house. The first task is to build a blueprint for the house. This blueprint would contain attributes and features of the house, such as the dimensions for each room, how the plumbing will flow, and so on.

Is the blueprint of the house the actual house? Of course not, it simply lists out the attributes and design elements for how the home will be created. So after the blueprint is completed, the actual home can be built — or, “instantiated”.

As explained in the previous section, in OOP, a class is the blueprint for an object. It simply describes what an object will look like and how it will behave. Therefore, instantiation is the process of taking a class definition and creating an object that you can use in a program.

Let’s create a new instance of our ApiConnector class and store it in a variable called api:

Now that we have an object created, we can use the api variable to work with the class attributes. For example, we can run the code:

[Out:]
https://next.tech

In addition to creating attributes, you can also create methods within a class:

To access this method, we can use the same syntax that we utilized with the attribute accessors:

Putting this all together, running the full class code below will result in the url and the test_method message to be printed:

[Out:]
"https://next.tech"
"testing class call"

Initializer Method

One thing you may find handy in Ruby development is the ability to create an initializer method. This is simply a method called initialize that will run every time when you create an instance of your class. In this method, you can give values to your variables, call other methods, and do just about anything that you think should happen when a new instance of that class is created.

Let’s update our ApiConnector to utilize an initializer method:

Within the initialize method, we created an instance variable for each of the parameters so that we can use these variables in other parts of the application as well.

We also removed the attr_accessor method since the new initialize method will take care of this for us. If you need the ability to call the data elements outside of the class, then you would still need to have the attr_accessor call in place.

To test if the initialize method is working, let’s create another method within the class that prints these values out:

Finally, we’ll instantiate the class and test the initialize method:

[Out:]
"My title"
"My cool description"
"https://next.tech"

Working with optional values

Now, what happens when we want to make one of these values optional? For example, what if we want to give a default value to the URL? To do that, we can update our initialize method with the following syntax:

Now our program will have the same output even if we don’t pass the url value while creating a new instance of the class:

Using named arguments

Though this looks simple, passing arguments can get complex in real-world Ruby applications because some methods may take a large number of arguments. In such cases, it becomes difficult to know the order of arguments and what values to assign to them.

To avoid this confusion, you can utilize named arguments, like this:

You can enter the arguments without having to look at the order in the initialize method, and even change the order of the arguments without causing an error:

Overriding default values

What happens if we want to override a default value? We simply update our instantiation call like this:

This update will override our default value of https://next.tech, and calling api.testing_initializer will now print https://next.xyz as the URL.

Inheritance

Now, we are going to learn about an important object-oriented principle called inheritance. Before going into how it is executed in Ruby, let’s see why it’s important for building applications.

To start with, inheritance means your classes can have a hierarchy. It is best used when different classes have some shared responsibilities, since it would be a poor practice to duplicate code in each class for identical or even similar behavior.

Take our ApiConnector class. Let's say we have different API classes for various platforms, but each class shares a number of common data or processes. Instead of duplicating code in each of the API connector classes, we can have one parent class with the shared data and methods. From there, we can create child classes from this parent class. With the way that inheritance works, each of the child classes will have access to the components provided from the parent class.

For example, say we have three APIs: SmsConnector, PhoneConnector, and MailerConnector. If we wrote code individually for each of these classes, it would look like this:

As you can see, we are simply repeating the same code across different classes. This is considered a poor programming practice that violates the DRY (Don’t Repeat Yourself) principle of development. Instead, we can make an ApiConnector parent class, and each of the other classes can inherit the common functionality from this class:

By leveraging inheritance, we were able to cut all of the duplicate code throughout our classes.

The syntax for using inheritance is to define the child class name, followed by the < symbol, then the parent class name — i.e. our SmsConnector, MailerConnector, and PhoneConnector classes inherit from the ApiConnector class .

Each of these child classes now has access to the full set of elements provided in the parent ApiConnector class. For example, if we create a new instance of SmsConnector with the following parameters, we can call the send_sms method:

[Out:]
Sending SMS message with the title 'Hi there!' and description 'I'm an SMS message'.

A rule of thumb in OOP is to ensure that a class performs a single responsibility. For example, the ApiConnector class should not send SMS messages, make phone calls, or send emails since that would be three core responsibilities.

Private and Public Methods

Before we dive into private and public methods, let’s first go back to our original ApiConnector class and create a SmsConnector class that inherits from ApiConnector. In this class, we will create a method called send_sms that will run a script that contacts an API:

This method will send a title and url to an API, which will in turn send an SMS message. Now we can instantiate the SmsConnector class and call the send_sms message:

Running this code will contact the SMS API and send the message. You can go to the bottom of this page to see your message!

Now, using this example, let’s discuss the types of methods provided by classes.

The send_sms method is a public method. This means that anyone working on our class can communicate with this method. This may not seem like a big deal if you are working on an application that no one else is working on. However, if you build an API or code library that is open sourced for others to use, it's vital that your public methods represent elements of functionality that you actually want other developers to use.

Public methods should rarely, if ever, be altered. This is because other developers may be relying on your public methods to be consistent, and a change to a public method may break components of their programs.

So, if you can’t change public methods, how can you work on a production application? That’s where private methods come in. A private method is a method that is only accessed by the class that it is contained in. It should never be called by outside services. This means that you can alter their behavior, assuming that these changes don’t have a domino effect and alter the public methods that they may be called from.

Usually private methods are placed at the end of the file after all the public methods. To designate private methods, we use the private word above the list of methods. Let’s add a private method to our ApiConnector class:

Notice how we’re calling this method from the inside of the initialize method of the ApiConnector class? If we run this code, it will give the following output:

[Out:]
A secret message from the parent class

Now child classes have access to methods in the parent class, right? Well, not always. Let’s remove the secret_method method from the initialize method in ApiConnector and try to call it from our SmsConnector child class, as shown here:

[Out:]
Traceback (most recent call last):
main.rb:29:in `<main>': private method `secret_method' called for #SmsConnector:0x000056188cfe19b0> (NoMethodError)

This is because the SmsConnector class only has access to the public methods from the parent class. The private methods are, by their nature, private. This means that they can only be accessed by the class that they are defined in.

So a good rule of thumb is to create private methods when they should not be used outside the class and public methods when they have to be available throughout the application or used by outside services.

Wrapping up

I hope you enjoyed this quick tutorial on the fundamental concepts of object-oriented programming in Ruby! We covered creating classes, attribute accessors, instantiation, initialization, inheritance, and private and public methods.

Ruby is a powerful object-oriented language used by popular applications, including our own here at Next Tech. With this foundational knowledge of OOP, you’re well on your way to developing your own Ruby apps!

If you’re interested in learning more about programming with Ruby, check out our Introduction to Ruby course here! In this course we cover core programming skills, such as variables, strings, loops, and conditionals, more advanced OOP topics, and error handling.

An introduction to Object-Oriented Programming with Ruby was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

Swift is a relatively new programming language designed by Apple Inc., and was initially made available to Apple developers in 2014. It was primarily intended as a replacement for the aging Objective-C language that was the foundation of OS X and iOS software development at the time. It was made open source in December 2015. While it remains primarily used by developers targeting the Apple macOS and iOS platforms, Swift is also fully supported on Linux, and there are unofficial ports under development for Windows as well.

Unlike many object-oriented languages, which are based on older procedural languages — for example, C++ and Objective-C are based on C — Swift was designed from the ground up as a new, modern, object-oriented language that makes programming faster and easier, and helps developers produce expressive code that’s less prone to errors than many languages.

While not based on an older language, Swift, in the words of its chief architect, Chris Lattner, “was inspired by drawing ideas from Ruby, Python, C#, CLU, and far too many others to list”.

In this quick crash course, we will cover the fundamentals of using the Swift programming language. You’ll learn:

• Basic Swift syntax
• Swift program structure
• Variables and constants
• Type inference
• Variable and constant naming conventions
• Printing and string interpolation

Let’s get started!

This crash course is adapted from Next Tech’s full Beginning Swift course, which includes an in-browser sandboxed environment with Swift pre-installed. It also has numerous activities for you to complete. You can check it out for free here!

Swift Syntax

In this first section, we’ll look at the basic language syntax for Swift.

Like many modern programming languages, Swift draws its most basic syntax from the programming language C. If you have previous programming experience in other C-inspired languages, many aspects of Swift will seem familiar, for example:

• Programs are made up of statements, executed sequentially.
• More than one statement is allowed per editor line when separated by a semicolon (;).
• Units of work in Swift are modularized using functions and organized into types.
• Functions accept one or more parameters, and return values.
• Single and multiline comments follow the same syntax as in C++ and Java.
• Swift data type names and usage are similar to that in Java, C#, and C++.
• Swift has the concept of named variables, which are mutable, and named constants, which are immutable.
• Swift has both struct and class semantics, as do C++ and C#.

However, Swift has some improvements and differences from C-inspired languages that you may have to become accustomed to, such as:

• Semicolons are not required at the end of statements — except when used to separate multiple statements typed on the same line in a source file.
• Swift has no main() method to serve as the program’s starting point when the operating system loads the application. Swift programs begin at the first line of code of the program’s source file — as is the case in most interpreted languages.
• Functions in Swift place the function return type at the right-hand side of the function declaration, rather than the left.
• Function parameter declaration syntax is inspired by Objective-C, which is quite different and often at first confusing for Java, C#, and C++ developers.
• The difference between a struct and a class in Swift is similar to what we have in C# (value type versus reference type), but not the same as in C++ (both are the same, except struct members are public by default).

Swift Program Structure — Hello, World!

To illustrate the basic structure of a Swift program, let’s create a simple Swift program to display the string Hello, World. to the console:

[Out:]
Hello, World

If you are using Next Tech’s sandbox, you can follow along with the code snippets in this crash course by simply typing in the editor. Otherwise, you can follow along with your own IDE — just make sure that Swift is installed!

Congratulations! In two lines of code, you’ve just written your first fully-functional Swift program.

Now, let’s move on to learning about and using the Swift language — and break down each part of your Hello World program!

Swift Variables

Virtually all programming languages include the ability for programmers to store values in memory using an associated name chosen by the programmer. Variables allow programs to operate on data values that change during the run of the program.

A Swift variable declaration uses the following basic syntax:
var <variable name> : <type> = <value>

Given this syntax, a legal declaration for a variable called pi would be:

This declaration means: “create a variable named pi , which stores a Doubledata type, and assign it an initial value of 3.14159”.

Swift Constants

You may want to store a named value in your program that will not change during the life of the program. How can we ensure that, once defined, this named value can never be accidentally changed by our code? By declaring a constant!

In our earlier Hello, World program, we declared message using let instead of var — therefore, message is a constant.

Since message was declared as a constant, if we added the following line of code to the end of our program, we would receive a compile-time error, since changing a let constant is illegal:

[Out:]
error: cannot assign to value: ‘message’ is a ‘let’ constant

Generally, any time you create a named value that will never be changed during the run of your program, you should use the let keyword to create a constant. The Swift compiler enforces this recommendation by creating a compile-time warning whenever a var is created that is not subsequently changed.

Other than the restriction on mutating the value of a constant once declared, Swift variables and constants are used in virtually identical ways.

Type Inference

In our Hello World example, we created the constant message without specifying its data type. We took advantage of a Swift compiler feature called type inference.

When you assign the value of a variable or constant as you create it, the Swift compiler will analyze the right-hand side of the assignment, infer the data type, and assign that data type to the variable or constant you’re creating. For example, in the following declaration, the compiler will create the variable name as a String data type:

As a type-safe language, once a data type is inferred by the compiler, it remains fixed for the life of the variable or constant. Attempting to assign a non-string value to the name variable declared above would result in a compile-time error:

[Out:]
error: “cannot assign value of type ‘Double’ to type ‘String’

While Swift is a type-safe language, where variable types are explicit and do not change, it is possible to create Swift code that behaves like a dynamic type language using the Swift Any data type. For example, the following code is legal in Swift:

While this is legal, it’s not a good Swift programming practice. The Any type is mainly provided to allow bridging between Objective-C and Swift code. To keep your code as safe and error-free as possible, you should use explicit types wherever possible.

Variable Naming Conventions

Swift variables and constants have the same naming rules as most C-inspired programming languages:

• Must not start with a digit
• After the first character, digits are allowed
• Can begin with and include an underscore character
• Symbol names are case sensitive
• Reserved language keywords may be used as variable names if enclosed in backticks. For example:

When creating variable and constant names in Swift, the generally accepted naming convention is to use a camelCase naming convention, beginning with a lowercase letter. Following generally accepted naming conventions makes code easier for others to read and understand.

For example, the following would be a conventional variable declaration:

However, the following would not be conventional, and would be considered incorrect by many other Swift developers:

Unlike many other programming languages, Swift is not restricted to the Western alphabet for its variable name characters. You may use any Unicode character as part of your variable declarations. The following variable declarations are legal in Swift:

Note that just because you can use any Unicode character within a variable name, and can use reserved words as variables when enclosed in backticks, it doesn’t mean you should. Always consider other developers who may need to read and maintain your code in the future. The priority for variable names is that they should make code easier to read, understand, and maintain.

Printing and String Interpolation

In Swift, you can print a variable or a constant to your console using the print() function. Let’s create a variable and a constant and print them out.

Execute this snippet in your Code Editor to create a constant named name, and a variable named address:

[Out:]
John Does lives at 201 Main Street

Both name and address store string text. By wrapping the variable or constant name in a pair of parentheses, prefixed by a backslash (\), we are able to print their stored values in a print statement — this is called string interpolation.

I hope you enjoyed this quick crash course on the basics of Swift! We learned about basic syntax and program structure, how to declare and use Swift variables and constants, type inference, printing, and string interpolation.

If you are interested in learning more about Swift, we have a full Beginning Swift course at Next Tech that you can start for free! In this course we cover:

• Other basic programming concepts such as: optionals, tuples, enums, conditionals and loops, methods, structs, and classes.
• Creating scripts and command line applications in Swift
• Using Swift outside of iOS and macOS development lifecycles

Happy learning!

Learn the basics of Swift in less than ten minutes was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

Collecting system metrics allows system administrators to monitor available resources, detect bottlenecks, and make informed decisions about servers and projects.

At Next Tech, we use system metrics we gather for many things, such as:

• Detecting an issue, like a server that doesn’t have enough resources.
• Conversely, for identifying areas we could be saving money by reducing a server’s resources.
• Ensuring that all services (like a web server or database) are running.

In this tutorial we will go over how to install and configure collectd, which is an open source daemon that collects system performance statistics and provides ways to store and publish them. Then, using the collectd's write_http plugin, we will send our metrics data to a Flask application using HTTP POST requests.

Let’s get started!

Step 1: Load a Python environment

The easiest way to jump into a Python sandbox is using the Next Sandbox, which gives you access to an online computing environment in a couple of seconds. You can click here to launch one, or here to read about how you can install Python on your computer.

Step 2: Installing collectd

The first step is to install collectd. You can do this by entering the following commands in your terminal:

apt-get update
apt-get install collectd

Once collectd is installed successfully, move on to the next step — configuring the daemon!

Step 3: Configuring collectd

We need to configure collectd so that it knows what data to collect and how to send the values collected.

The collectd configuration file can be found at etc/collectd/collectd.conf. If you know Vim, you can modify the configuration file directly by running:

vim etc/collectd/collectd.conf

Otherwise, we will link the config file to one that is easily editable in the Sandbox. To do so, run the following three commands in your terminal to link the original configuration file to our new one:

cp /etc/collectd/collectd.conf /root/sandbox/collectd.conf
rm /etc/collectd/collectd.conf
ln -s /root/sandbox/collectd.conf /etc/collectd/collectd.conf

Now, open the file and take a look at the default collectd configuration. There are four sections in this file: Global, Logging, LoadPlugin Section, and Plugin Configuration.

Global

The first part of the file displays the Global Settings. The lines beginning with a hash (#) are commented out — we will remove some of these hashes so that these settings are as follows:

Logging

The next section of the configuration file displays plugins used for logging messages generated by the daemon when it is initialized and when loading or configuring other plugins.

For each plugin in this section (and the next), there is a LoadPlugin line in the configuration, followed by the plugin's options. Almost all of these lines are commented out in order to keep the default configuration lean.

Only one log plugin should be enabled. We will be using using LogFile.

Remove the hash before the LoadPlugin logfile line and edit the plugin configuration to write the output to this file by changing the File parameter. This section should look like this:

Make sure the default logging plugin syslog is either removed or commented out.

LoadPlugin section

The next section displays a list of features. By default the following plugins are enabled:

Our collectd daemon will automatically collect data using these plugins. A full list of the available plugins and a short description of each can be found here.

We also want to enable the write_http plugin so that collectd will know where to send the data it collects:

Find this plugin in the list and remove the hash to enable it.

Plugin configuration

The final section shows the configuration for all the listed plugins. You can see all the plugin options in the collectd.conf(5) manual.

Find the plugin configuration for write_http. We will modify this to look like the following:

Note that we specified the format of our output to be in JSON.

We will not be modifying any of the other plugin configurations but feel free to do so on your own.

Step 4: Verifying configuration

It is important to restart collectd whenever the configuration file is changed. Run the following command in your terminal to do so:

systemctl restart collectd

You can also run this command to check the status of collectd:

systemctl status collectd

If all is working, you should see Active: active (running) in the output.

You should also be able to see that collectd was initialized and plugins were loaded in your collectd.log file.

Finally, we can verify whether there are issues in the configuration file by running the following:

collectd -t ; echo $?

This command tests the configuration, then exits. It should return the output 0.

Step 5: Creating a Flask app

We’ve gotten configd to track our metrics properly...now let's create a web application using Flask so collectd can send this data via HTTP POST requests!

Flask is a powerful microframework for creating web applications with Python. It comes with an inbuilt development server and is a perfect framework to build RESTful web services. The route decorator which helps to bind a function to a URL can take the HTTP methods as arguments that pave a way to build APIs in an ideal manner.

First, let’s install Flask by running the following:

pip3 install Flask

Now, create a new file called flask_app.py.

There are three steps to write this program:

1. Create a WSGI application instance, as every application in Flask needs one to handle requests.
2. Define a route method which associates a URL and the function which handles it.
3. Activate the application’s server.

Copy the following code into the flask_app.py file in your directory:

This snippet executes the first two steps — we created a WSGI application instance using Flask’s Flask class, and then we defined a route which maps the path '/' and the function get_data to process the request using a Flask's decorator functionFlask.route().

Within the Flask.route() decorator, we specified the request methods as GETand POST. Then, our get_data method prints the incoming request data using request.data.

Continue on to the final step in our lesson to activate the application’s server to see our data!

Step 6: Running a Flask app

To run your Flask application, you need to first tell the terminal what application to work with by exporting the FLASK_APP environment variable:

export FLASK_APP=flask_app.py

Then, execute the following to enable the development environment, including the interactive debugger and reloader:

export FLASK_ENV=development

Finally, we can run the application with the following:

flask run

After the app start running, in your terminal you should see your collectd data coming in as a JSON output!

Summary

In this tutorial we covered:

1. Installing collectd
2. Configuring multiple collectd plugins
3. Building a basic Flask application
4. Receiving data from collectd inside of Flask

We hope you enjoyed this tutorial and learned something new! If you have any comments or questions, don’t hesitate to drop us a note below.

This tutorial was extracted from a lesson on Next Tech. If you’re interested in exploring the other courses we have, come take a look!

Tracking System Metrics with collectd was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

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 Go), 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:

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:

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 version of Go 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!

Launch VS Code in online computing environments was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

Technology publisher Packt and computing infrastructure provider Next Tech have announced that they are partnering in a bid to bring Packt’s diverse library of learning resources to a new audience of software engineers and developers via interactive labs that provide online access to real world developer environments.

Combining Packt’s considerable experience in publishing on the latest open source software and Next Tech’s innovative approaches to content delivery and learning experiences for technical skills, the partnership promises to be an important step forward in supporting the people powering the growing open source ecosystem.

Packt Publishing’s Head of Channels and Partnerships Heather Gopsill said “Next Tech is a company that shares many of our values, including a commitment to learning and a belief in innovation. That makes our partnership with them incredibly exciting, as it gives us an opportunity to deliver our latest content in new ways.”

Next Tech’s CEO Saul Costa was equally optimistic about the potential for the partnership, saying “Packt has done an incredible job of building a vast network of authors who produce high quality technical training materials. We’re excited to combine these with the online IDE we’ve built for teaching tech skills and together take technical education to a new level.”

The first of these products are currently available via Next Tech's website. Packt plans to incorporate the products into their subscription service in the coming months at a large scale. If you'd like to learn more about how you can use interactive tech training labs as part of your offering, please contact sales@next.tech.

About Next Tech

Next Tech’s smart-scaled computing infrastructure powers the learning experiences of hundreds of thousands of students around the world as they master tech skills. Since their founding in 2014 they have maintained a laser focus on building high tech products that both beginners and advanced users can benefit from.

Visit Next Tech: https://next.tech

Follow Next Tech on Twitter: @nextdottech

Find Next Tech on Facebook.

About Packt Publishing

Packt Publishing provides learning resources for software developers. Beginning in 2004 as a book publisher, the organization has evolved to develop courses, videos, and live training on the latest technologies and trends. With a subscription service that offers full access to all of the content the publisher has produced, and a brand new technology news and insights platform, Packt is committed to helping software developers stay up to date with what matters.

Visit Packt: www.packtpub.com

Follow Packt on Twitter: @PacktPub

Find Packt on Facebook

Packt and Next Tech partner to bring interactive tech education to developers was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article we’ll explore the powerful OpenWeatherMap API, which allows you to access and use weather data in your programs. It can be used to display information such as the temperature, wind, and humidity, for the current weather and for the forecasted weather.

We’ll use the Python programming language and an awesome library called Python OpenWeatherMap (PyOWM) to make it easier to use the OpenWeatherMap API in Python.

This article is based on an interactive course released on Next XYZ by Andrew Sverdrup, a software engineer at Next Tech. The course has Python and the PyOWM library preinstalled and lets you use both directly from your browser. If you want to learn even more about PyOWM , you can check out the course for free.

Setting Up Your Environment

To run the code snippets in this article you’ll need to have Python and the pyowm library installed (install instructions for pyowm can be found here).

Getting your OpenWeatherMap API Key

Once you have your environment setup, the next step is to get your free API key from the OpenWeatherMap website.

After you’ve signed up on OpenWeatherMap’s website, you’ll see this at the top of the page:

Click on “API keys” and you’ll see the API key.

When you work with the the examples below, you’ll need to replace <api_key> with this API key.

Weather Conditions

Now that you have your API key, let’s check the weather! First we’ll start by checking if there are any clouds in the five-day forecast for Los Angeles. Here’s the code to do that:

Let’s break this down. We start by importing the pyowm library, then we authenticate using an API key. The authenticated connection to the API is stored in the owm variable.

Next we use the three_hours_forecast() method to get the forecast for a specified location (in this case, Los Angeles) and store it in the la variable. Note that the three_hours_forecast() method returns a five-day forecast with weather data sampled every three hours.

Now that we have the weather object, we can call the will_have_clouds() method on it to check if there will be clouds! Within the pyowm library, this will check the weather at each three-hour interval and if any weather sample indicates there will be clouds, the method will return true, otherwise it will return false.

We can also use PyOWM to see if it will rain, be foggy, or check for other common weather conditions. OpenWeatherMap has data from all around the world as well. For example, let’s take a look at the weather in London:

Awesome! With just a few lines of code you can get and display some amazing information in your program.

Current Temperature

Now let’s take a look at how to get the current temperature:

As you might guess from the use of 'fahrenheit' in the above code, you can also request the data in Celsius by passing 'celsius' to the get_temperature() method.

Sunrise and Sunset Times

Another cool thing you can do with PyOWM is request and display the sunrise and sunset times. The get_sunrise_time() and get_sunset_time() methods can be called to get this info. There is a catch when using these methods though- they return the time in unix time by default (e.g., 1542800608). Passing the timeformat='iso' parameter converts the time to a more human-readable format (e.g., 2018–11–21 21:16:54+00). Also, the times are in the GMT timezone (in the Next XYZ course we cover how to convert the times to a specific timezone).

Here’s an example of getting the sunrise and sunset times:

Wrapping Up

If you enjoyed this post and want to learn more about using Python OpenWeatherMap to access weather data, check out the course on Next XYZ, which goes more in-depth into how to use PyOWM. It also includes interactive tasks and quizzes which will help you master the material in the course. By the end of it you’ll have created a weather GUI just like the image below!

Have any questions or comments? Just leave a response below!

Thanks for reading, and happy coding!

How to use the OpenWeatherMap API with Python was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.

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

An interview with Andrew Sverdrup, author of the new Next XYZ Python OpenWeatherMap course.

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 Tech 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!

Learning Python OpenWeatherMap with Andrew Sverdrup was originally published in Next Tech on Medium, where people are continuing the conversation by highlighting and responding to this story.