Carlos Saucedo

My Summer Internship Experience at CPS Products, Inc.

2019-08-25T00:00:00+00:00

This summer, I was an Engineering/Web Intern at CPS Products, Inc. Throughout my internship, I learned and refined lots of skills that I’ll be taking back and using in my career for years to come. The internship encompassed many different categories, including Web Development/WordPress Management, Software/Mobile App Development, Competitive Analysis and Research, and more. Over the course of the internship, I discovered TypeScript and added it to my skillset, and was able to refine and modernize my Apache Cordova experience with the newer Ionic framework, and was able to apply my skills to create a production-grade application that’s in the works of being deployed today. Additionally, with some of the knowledge I amassed throughout the internship, I was able to develop a standalone app that allows you to communicate with a BLE (Bluetooth Low Energy), device as a terminal. I also learned some helpful tools to optimize a WordPress Website, and even managed to increase PageSpeed Insights by more than 50 points on several sites.

Ionic and the Future of App Development

Ionic has become my favorite tool for quickly creating desktop, web, and mobile apps beautifully and efficiently.

One of the most impactful technologies I learned throughout the internship was Ionic, the new app development framework. I had some previous experience with Apache Cordova throughout my last internship, but overall, pure Cordova felt a bit dated and clunky. Ionic also has the advantage of having an incredible CLI, which allowed me to create projects, add components to my projects, generate resources such as splash screens and app icons, and compile and run on an emulator or connected device. Additionally, Ionic uses TypeScript and Angular by default, both of which I had to learn in order to create the apps I did this summer. Ionic is my favorite method to creating apps because it allows you to use web-heavy development to produce Native code on Android, iOS, and more. This summer I was assigned the task of developing an application that interfaces with BLE devices and sends and receives information that is gained from the sensors onboard the various Bluetooth Devices CPS Products uses.

My Bluetooth Terminal app running on Android.

In order to learn the workflow of creating Ionic applications and handling BLE devices, I created a separate BLE Terminal on my own time that actually became a really powerful tool I was able to use to test the subsequent apps I was developing. Though simple, the Terminal app proved to be extremely useful, and allows both sending and receiving of ASCII text to and from a BLE device with an optionally adjustable characteristic and service UUID sets. Learning how BLE works and applying it to my existing code was one of the most difficult tasks I had to undertake while on this internship, but once I was able to create a base class in TypeScript that performed all of the Bluetooth Functions, I was set.

I ended up using Apache Cordova instead of the newer capacitor, because of my previous experience with Cordova and because of the increased plugin support. This ended up being just as efficient though, especially when creating an application with heavy third-party plugin requirements.

Making WordPress More Efficient

Source

Another one of the useful takeaways from the internship was being able to learn some effective steps to make any WordPress site more efficient, through things such as WP Super Cache, Autoptimize, and using CDNs. Though I’d had previous experience managing WordPress websites, page speed wasn’t ever a priority, but I was able to really focus on it during this internship and was able to improve the PageSpeed Insight Score of all 3 CPS Products websites by 50 points or more.

Another really important procedure I was able to develop was a workflow to automatically make uploaded images be resized, compressed, and served through a CDN instead of through the website itself. This dramatically increased website speeds and was by far the biggest improvement to the PageSpeed Insight Score. In the future, I hope to take this knowledge and be able to apply it to the improvement of many WordPress sites, especially those with high traffic that depend on low latency.

Competitive Analysis for Research and Development

The last big contribution I was able to make to the team, though not quite related to Software Engineering, was working with the Research and Development as well as the Marketing and Sales teams in order to conduct competitive analyses for different products that were in the pipeline for release or were being considered for development. This was an interesting insight on how similar companies compete to gain an improving market share, and provided lots of information on the HVAC/R industry as well as general business knowledge that gave me more information on how different sectors of a company I’m not traditinally working with directly operate and function, as well as integrate with engineering teams I tend to be more often a part of.

Conclusion

Over the summer, I did a wide variety of things and was able to dramatically improve my Software Engineer experience as well as my overall business fluency in an entirely new industry. I’m extremely thankful to CPS for having provided me this opportunity, and look forward to seeing where the experience I’ve gained takes me!

Creating a Simple To-Do App with TypeScript, Node, SQLite, and ExpressJS

2019-08-09T00:00:00+00:00

Have you found yourself needing a place to keep a list of To-Dos, but don’t trust big companies with having all of your information? Need the most lightweight todo client possible that you can access from anywhere? Want to be able to share a To-Do list with anyone, without having them download fancy apps and set up accounts? I certainly have, and instead of scouring the internet to try to find a solution, I decided to build it myself. The product ended up being a Node server using ExpressJS to render the webpage, using TypeScript to handle backend requests, and storing the To-Dos on an SQLite server on the server. Though this was only truly intended as a tool to learn the technologies and putting them together, it technically is a fully functional To-Do list, and I might just plan to use it in the future for quick and dirty tasks to keep track of.

This tutorial is heavily inspired by missating’s nodejs-todo project. Thanks!

Set up and installation

Node

Node is Server-Side JavaScript that you can use just as you would any other server-side language like Java or Python. Our application depends on this because we’ll be using several different Node packages, such as the sqlite3 package to store our data and the ejs (ExpressJS) package to server our front-end website. Getting it installed depends on your architecture; if you have Ubuntu/Debian, you can simply run

sudo apt-get install nodejs

Otherwise, you’ll want to look at the Node downloads page to install it.

After you have it installed, you’ll want to check to make sure it works by opening a terminal and typing in npm -v. If you get a response, congratulations! You’ve got everything working.

TypeScript

As a developer with a higher concentration in strongly-typed languages, TypeScript is probably my favorite tool for modern, web-first programs and applications. TypeScript compiles directly to JavaScript, meaning that its use can be applied to any project that uses JavaScript, and it keeps things in check more so that pure JavaScript. To get it downloaded, you’ll have to install it within node:

npm install -g typescript

This will install Express globally. If you would like to install it only for this project, you can do so with npm install typescript --save.

ExpressJS

ExpressJS is a lightweight Node.js web framework that’s going to get us up and running really quickly. In order to install it and add it to our project, we’re going to run the npm command, which is the Node Package Manager:

npm install express --save

BodyParser

BodyParser is a module we’ll need to help us handle values we transfer to and from the database. Install it with:

npm install body-parser --save

SQLite

SQLite is our choice for databases here because of how light it is, how portable it is, and how easy it is to back up/migrate it whenever we need to, as it saves everything into a .db file. It uses a simplified SQL language version, and has <1ms response times!

Like with Express, the installation goes as follows:

npm install sqlite3 --save

Now that we have all of our dependencies, installed, we’re ready to create a new project and get coding!

The Fun Stuff

Here is the repository where I host the current iteration of the todo app. If you’d like to skip the following along part, you can just fork this repository.

The first thing we’re going to do to start off our coding is some simple Node and Express things:

Create a new directory named todo-mini.
Navigate to the directory in a terminal and run npm init.
Fill out the requested information in as much depth as you like, making sure to set the "main" field to index.ts instead of index.jsbecause we’re using TypeScript.
Create a new file called index.ts and open it in your favorite text editor.

Configuring TypeScript for Node

Because we’re going to be using TypeScript instead of pure JavaScript for our Node app, we have to make some slight configuration changes to our package.json:

Under "scripts", we’ll add "tsc": "tsc" so that we can compile our TypeScript into JavaScript when we run our app.
We’ll double check that our "main" is set to "index.ts".

Note: We can also set this within the initial configuration.

Hello World

Inside our index.ts, we first import all of our dependencies:

// Import all of our dependencies
var express = require("express");
var bodyParser = require("body-parser");
var app = express();

We’ll also be importing some TS files we’ll write ourselves, but we’ll do that later.

Now, let’s configure Express to serve us some web:

// Instantiating the Express object.
var app = express();

// Handles whenever the root directory of the website is accessed.
app.get("/", function(req, res) {
  // Respond with Express
  res.send("Hello world!");
});

// Set app to listen on port 3000
app.listen(3000, function() {
  updateValues(function() {
    console.log("server is running on port 3000");
  });
});

Once this is done, if we run our Node app with:

npm run tsc && node build/index.js

and we navigate to the website we just hosted at http://localhost/4000, we should see it return Hello World!

Creating our To-Do List

While really cool, this doesn’t really let us do anything with or to-dos! Let’s actually design the view that we’re going to be seeing:

SQL Module

First, before we do anything, we need to create our SQLite database and create the appropriate tables we’ll be accessing later on within our sqlite3.ts file. The way you’ll do this varies depending on your development environment, but for me, using VSCode and the SQLite extension, I just have to open the command palette and type in New Quick Query, and write the following:

CREATE TABLE todo(
  task text
);

CREATE TABLE done(
  task text
);

We should now have two tables created, which store a text value of the task to do. That way, if we need to add more functions later on, it’s easy to add columns to each table.

Now, we have to write the SQL module that creates the database and sets up the framework so that we can store our to-dos. Create a new folder named modules and add a new file named sqlite3.ts inside it, and then import and initialize sqlite within our custom module.

sqlite3.ts:

// Importing SQLite3 to our project.
var sqlite3 = require("sqlite3").verbose();
// Setting up a database for storing data.
var db = new sqlite3.Database("database.db");

Since this is a Node module, we’ll write it a little bit differently index.ts. We’ll encase all of our functions within module.exports, like so:

module.exports = {
  // All of our functions go here.
};

Inside of module.exports, we’re going to place functions that handle our requests from index.ts, namely, an ability to add tasks, mark them as completed, and remove the ones that have already been completed. We’ll also add functions to fetch the incomplete and complete tasks so we can populate the website whenever we refresh the page.

First, the function to get the incomplete tasks:

  getTodoList: function(callback:any){
    db.all("SELECT * FROM todo", function(err:any, res:any){
      callback(res);
    });
  },

Similarly, another function to get the incomplete tasks:

  getDoneList: function(callback:any){
    db.all("SELECT * FROM done", function(err:any, res:any){
      callback(res);
    });
  },

Then, functions to add, mark as complete, and clear completed tasks:

  addTask: function(taskName:string, callback:any){
    // Add a task to the todo list.
    db.run("INSERT INTO todo VALUES ($task)", {
      $task: taskName
    }, function(){
      callback();
    });
  },

  completeTask: function(taskName:string, callback:any){
    // Delete the task from the todo list.
    db.run("DELETE FROM todo WHERE task=$task", {
      $task: taskName
    }, function(){
      db.run("INSERT INTO done VALUES ($task)", {
        $task: taskName
      }, function(){
        callback();
      });
    });
  },

  clearComplete: function(callback:any){
    // Delete all cleared tasks.
    db.run("DELETE FROM done", function(){
      callback();
    });
  }

These are all pretty straightforward SQL commands that we just interface through the SQL plugin with. If you would like more background knowledge with SQL, w3schools provides a great set of tutorials on SQL.

TypeScript

Before we can render HTML with Express, we’ll have to add these lines right after our require statements. These settings allow us to use Express, our CSS, and the custom made HTML we’re about to write.

// Set up BodyParser.
app.use(bodyParser.urlencoded({ extended: true }));

// Set the view engine to use Express.
app.set("view engine", "ejs");

// Custom-made SQLite module.
var sqlite = require("./modules/sqlite3");

// Render the CSS Files
app.use(express.static("public"));

After we’ve done that, we will change the default root directory action to access our index.ejs file instead of printing “Hello World!”:

// Render the ejs and display added task, completed task
app.get("/", function(req: any, res: any) {
  updateValues(function() {
    res.render("index", { task: task, complete: complete });
  });
});

TypeScript Functions

Now, we’ll write the HTML request endpoints so that we can query information:

index.ts:

// Adding a new task.
app.post("/addtask", function(req: any, res: any) {
  var newTask = req.body.newtask;
  // Add the new task from the post route.
  sqlite.addTask(newTask, function() {
    res.redirect("/");
  });
});

// Removing a task.
app.post("/removetask", function(req: any, res: any) {
  var completeTask = req.body.check;
  sqlite.completeTask(completeTask, function() {
    res.redirect("/");
  });
});

// Clearing all complete tasks.
app.post("/clearcomplete", function(req: any, res: any) {
  sqlite.clearComplete(function() {
    res.redirect("/");
  });
});

We’ll also need a function to update the values of the tasks and their completion status every time the app refreshes:

/**
 * Updates the todo/done lists.
 */
function updateValues(callback: any) {
  sqlite.getTodoList(function(result: any) {
    task = result;
    sqlite.getDoneList(function(result: any) {
      complete = result;
      callback();
    });
  });
}

Now, we should have all of the necessary components in the backend to handle all of our functionality. Now, to spice things up with HTML and CSS.

HTML (EJS)

To actually write the HTML contents of our app, we’re going to want to create a new EJS directory named views in our root directory, and create a new file titled index.ejs. Though the extension isn’t .html, it will actually render as it, so hopefully your IDE highlights it as such.

We’ll place the following in that index.ejs file:

This places all of our necessary components, and defines all the necessary HTML requests so that we can access and insert information into our to-do list:

addtask
- Allows us to add a task.
removetask
- Allows us to mark a task as completed (remove it from the to-do list)
clearcomplete
- Clears all of the completed tasks.

Now that we’ve defined these requests in the HTML, we’ll move on to the TypeScript file and add some endpoints to them.

CSS

I won’t be going too much into detail with the CSS, because it’s a long thing to teach in one article that doesn’t focus too much on it, but I’ve made available my CSS Stylesheet for this project. You’ll want to download this file and place it under todo-mini/public/ to import this CSS to our project. You can mess with these settings as much as you’d like - the CSS I have written is a bit simplistic but you can tune it up a lot!

Running the program

That’s it! We’ve successfully employed SQLite, Node, TypeScript, and EJS to create a simple To-Do list with persistent storage. Go into a terminal and navigate to the directory of your project, and type:

npm run tsc && node build/index.js

Then, navigate to the app:

http://localhost:3000/

And revel at what you’ve accomplished.

See you next time, and happy coding!

How to Use the Wolfram Alpha API in Python

2019-06-27T00:00:00+00:00

If you’re a Computer Scientist, Physicist, Mathematician, or just an analytical person that likes fast, accurate computation with a knowledge base that is unmatched anywhere else in the world, then you’ve probably worked with WolframAlpha before. Whether for computations, unit conversions, or word definitions, Wolfram seems to have an answer to pretty much every single important question out there, and being able to harness that ability and apply it to our own programs is perhaps one of the most powerful add-ons we can add to an AI or chatbot to enhance responses quickly and easily. In this Quick Tip, we’ll be going through how to integrate WolframAlpha into your Python program to instantly beef up your data power.

API Authentication

Creating an Account

In the free plan, we get access to 2,000 free queries per month, which so far has been enough for all of my applications (even those with 120,000+ users!). If you’re going to be having a small to medium-sized project, the free plan should suffice.

First, you’ll need to create a WolframAlpha API account.

The WolframAlpha API Dashboard.

When you verify your email address, you’ll be redirected to the dashboard, and you’ll be able to proceed to the next step!

Getting Your API Key

In the dashboard, click the Get an AppID button.

Enter the relevant details for the app.

When you click on create, a new API key will be generated for your records. Store this token - it’s what you’ll need to authenticate with the Wolfram API! Once you write it down, we can move on to the next step - setting up our code to authenticate the key, and writing queries and getting responses!

Keep this API key for your records!

Installation

First, you’ll need to install the wolframalpha dependency:

pip install wolframalpha

Next, you’ll be able to download or copy the gist I created for interfacing with Wolfram Alpha:

Save this as wolframapi.py in the root folder of your Python program. Then, in your main Python file, import the module:

import wolframapi as wolfram

Usage

Once you’ve imported all the necessary modules, you’ll be able to very easily create a new Wolfram Client object and interface with it.

First, instantiate the Wolfram Client as a variable:

client = wolfram.Client("YOUR_CONFIG_KEY_HERE")

If no errors are returned, authentication succeeded! Now, you’ll be able to easily query responses like so:

print(client.ask("Weather in Tallahassee, FL"));

If everything is correct, you should get a detailed, multiline response:

A bit hot, don’t you think?

And that’s it! You can now customize it to your heart’s desire. Feel free to implement any changes to my small API, as well as use this code on your programs of any scale whatsoever!

Conclusion

With WolframAlpha, you’ll be able to create extremely intelligent responses to almost any prompt, from weather, to unit conversions, to Calculus. It’s something that I consider essential to all of my AI applications, and sometimes use it for quick conversions so as not to install loads of different modules. I hope you found my Quick Tip interesting, and happy coding!

Exploring the New Microsoft Terminal

2019-06-25T00:00:00+00:00

It’s officially summertime, and with that comes the hottest-anticipated programming product for Windows users: the Windows Terminal! In this post, I’ll be running through my quick thoughts about it, and how it will be affecting my programming workflow, as well as the specific settings that I modified it to give it the “Carlos Way” touch.

Preface

The Windows Terminal is still in early alpha, and many of its features will be changing. This is definitely not anything near what the final product will look like, and shouldn’t be your final judgement on whether you should be using it or not. However, it does provide a good insight into what your workflow might look like if you end up using it, so it’s still worth a look!

Interface

The Windows Terminal with an active CMD tab.

I’m actually quite pleased with how the terminal looks. Aside from a couple of design discrepancies, in my own opinion, the Windows Terminal is a huge improvement over the traditional command prompt, and has some impressive theming options that bring it to the 21st century. It has an optional, customizable transparency setting, which, just like the new Calculator app, glosses over the contents behind it in a sleek, modern style. It also has a nice, tabbed interface that reminds me more of a Google Chrome dark theme than a terminal interface. It has the ability to display emoji, and has hyperlinks you can click on, like the terminal in VSCode.

Tabs

One of the most acclaimed new features of the Windows Terminal, the tabbed interface is just that - the ability to have more than one instance within a Windows Terminal window. Unlike other terminal programs for Windows and Unix, however, the Windows Terminal allows tabs of different environments and operating systems within one window, a new feature I will be using greatly.

When you click on the new tab button, a new tab from the default profile appears, but if you want to open a tab in another profile, you can select it from the dropdown button right next to it:

The tabs selector is fully customizable with profiles in the settings menu.

Every aspect of these dropdown options is able to be customized, from the titles and icons to the precise shell they are running. Your existing shells, both WSL and Microsoft, should be automatically populated, but they are easy to add if for some reason they have not been.

Customization

In my opinion, the customization process is probably what needs the most work so far. However, much to the style of Visual Studio Code, almost everything about the Windows Terminal can be customized. When clicking on the settings button in the dropdown, as shown above, you are met with a Visual Studio Code instance of the JSON settings file, and can edit it just as you would any other text file:

The settings dialogue.

While more hardened programmers will find this a possible positive change, more casual terminal users might find this slightly difficult to work with, especially those not so familiar with JSON. For my purposes, VSCode with a Color Info Plugin did an amazing job at letting me adjust theming and organize everything the way I needed it to. When opening the JSON file, your first relevant find will be all of the keybindings. I chose to leave them be for the time being, but it’s good to know that they’re all completely modular. Second, the list of profiles defines what kinds of tabs you can open:

Profiles

Profiles should be initially generated for you when you first install and run Windows Terminal. However, if you ever need to edit them to fit your specific needs - I adjusted the fontSize, cursorShape, and colorScheme to a custom scheme I created just for my Ubuntu instance, which you’ll see below. The settings are pretty self explanatory, but if you don’t know what you’re doing you probably don’t want to be prodding around and accidentally break your terminal.

When designing my Ubuntu profile, I was aiming for making it as similar to the Ubuntu Unity color scheme, with a little bit of transparency for an added touch of modernity.

Here’s my final adjusted Ubuntu profile:

"profiles" :
[
    {
        "acrylicOpacity" : 0.75,
        "closeOnExit" : true,
        "colorScheme" : "Ubuntu",
        "commandline" : "wsl.exe -d Ubuntu-18.04",
        "cursorColor" : "#DCDFE4",
        "cursorShape" : "filledBox",
        "fontFace" : "Ubuntu Mono",
        "fontSize" : 16,
        "guid" : "{c6eaf9f4-32a7-5fdc-b5cf-066e8a4b1e40}",
        "historySize" : 9001,
        "icon" : "ms-appx:///ProfileIcons/{9acb9455-ca41-5af7-950f-6bca1bc9722f}.png",
        "name" : "Ubuntu-18.04",
        "padding" : "0, 0, 0, 0",
        "snapOnInput" : true,
        "useAcrylic" : true
    }
]

Themes

Themes are also one of the hottest features new to the Windows Terminal. While the antiquated Command Prompt did have some limited theming options, I always found it underwhelming and lacking in color displays. However, since it was so ingrained into my Windows instance, there was no choice but to use it - and I had to resort to flimsy

If you want a profile to use with your Ubuntu instance, here are the settings I adapted from the internet:

"schemes": [
  {
      "background" : "#300A24",
      "black" : "#0C0C0C",
      "blue" : "#729FCF",
      "brightBlack" : "#555753",
      "brightBlue" : "#61AFEF",
      "brightCyan" : "#34E2E2",
      "brightGreen" : "#8AE234",
      "brightPurple" : "#AD7FA8",
      "brightRed" : "#EF2929",
      "brightWhite" : "#D3D7D9",
      "brightYellow" : "#FCE94F",
      "cyan" : "#06989A",
      "foreground" : "#EEEEEE",
      "green" : "#4E9A06",
      "name" : "Ubuntu",
      "purple" : "#AD7FA8",
      "red" : "#CC0000",
      "white" : "#DCDFE4",
      "yellow" : "#C4A000"
  }
]

Performance

Because this is a pre-alpha release, I found several bugs that were quite finnicky and caused things to crash. Every time I closed all of the tabs in the terminal, a clear window would hang for several seconds before finally closing. Only the small white section in the top right allowed the window to be properly dragged as well, which gets a lot more irritating than you think after a while. The app would stop responding ever time I closed a PowerShell session, forcing me to lose all of my progress made in the other tabs of the window. And miscellaneously, I would experience flickers on the window and slow minmization, maximization, resizing, and moving of the windows. I truly would not recommend you to use Windows Terminal as your main terminal emulator just yet, but since it will be an Open Source Windows product, I’m confident that it will eventually become just as stable as your old-school CMD. That’s the struggles of being a bleeding-edge early adopter, however, and we sign up for this!

Conclusion

The Windows Terminal is definitely something I’m going to have to keep an eye on. I’m already using it little by little in my less important projects, and just to pull up htop on my VPS instances to make sure that everything is running smoothly. My go-to for programming is still the VSCode terminal, but since that can’t pop out or be opened in a new window, it is still fairly difficult to integrate to a multi-monitor workflow. Thanks for reading, and happy coding!

How to Monitor Your Program’s Status with Pushbullet

2019-06-18T00:00:00+00:00

Pushbullet has always been a service essential to my tech life. It allows you to send and receive SMS messages from any android device within just about any internet-connected device, allows you to sync Android notifications with chrome or Windows, and even lets you easily transfer files to and from your phone and computer. I always knew Pushbullet had an API, but I’d never put two and two together to successfully make a notification system every time my Discord bot, Rikka, gets an error or restarts. In this quick tip, I’ll walk you through how I added Pushbullet notifications that notify me of the error, traceback, and timestamp.

Requirements

Python 3
A Pushbullet account
Basic Knowledge of Python and pip

Setup

Python Installation

First, install the Python module Pushbullet.py.

Obtaining the Pushbullet API Key

Then, you’ll need to get your API Key from Pushbullet. This is actually a really simple process.

Navigate to your Pushbullet Settings and click on Create Access Token. You’ll need to copy the key and save it somewhere.

The Pushbullet Access Key Token screen

pip install pushbullet.py

Quick Examples

Pushing Text Notes

In order to test your API key and make sure that everything works, you’ll first want to run a couple of tests in the python console.

First, import Pushbullet and authenticate using the access key you got in the previous step:

from pushbullet import Pushbullet
pb = Pushbullet(api_key)

Now, you can easily push a text note using:

pb.push_note("Quick Tip", "This is the best blog ever!")

And, the output should show in your Pushbullet window, like this:

Pushing Files

Pushing files is a bit of a more complex process, but it’s still really easy to learn!

First, we’ll create a small text file and write something to it:

touch hi.txt
echo "Hello World!" > hi.txt

Next, we’ll push it to Pushbullet:

with open("hi.txt", "r") as file:
  # Open the log as a file
  # and push it to yourself.
  file_data = pb.upload_file(file, "hi.txt")
pb.push_file(**file_data)

You should receive this in your Pushbullet:

If you’ve gotten up to this point, you’re halfway there! Now, let’s look at how to fit this into our current programs.

Pushbullet Error Handling

API Approach

Since my use case was with my Discord bot, Rikka, I was able to use the Discord.py API to find a function, on_error, that would catch all of the errors that occurred during the runtime of the program. When I overrode it, I was able to not only print the error to the console, but also create a text log with all of the errors, and notify myself:

@client.event
async def on_error(self, event_method, *args, **kwargs):
  # Print out a message indicating there was an error.
  print("Error.txt for details...")
  print(file=sys.stderr) # Print out any error details.
  # Create or append to error log if it exits.
  f = open("error.txt", "a+")
  f.write("===== ERROR SUMMARY =====\n")
  # Add timestamp of the error occurring.
  f.write("Timestamp: " + str(datetime.datetime.now().strftime("%d.%b %Y %H:%M:%S")) + "\n")
  # Write the exception that occurred.
  f.write("Exception in {}".format(event_method) + "\n")
  f.write("===== TRACEBACK =====\n")
  # Print out the traceback of the error.
  f.write(traceback.format_exc() + "\n\n")

  # Once the file is created and all of the information
  # is printed, push it to Pushbullet.
  with open("error.txt", "r") as file:
    # Open the error log as a file
    # and push it to yourself.
    file_data = pb.upload_file(f, "error.txt")
  push = pb.push_file(**file_data)

Try-Catch Approach

If you don’t have the fortune to be working with a great API that gives you an error-handling API, you can sort of write one yourself by placing everything in a try-catch:

try:
  yourFunctionHere()
except:
  # Print out a message indicating there was an error.
  print("Error.txt for details...", ERROR)
  print(file=sys.stderr) # Print out any error details.
  # Create or append to error log if it exits.
  f = open("error.txt", "a+")
  f.write("===== ERROR SUMMARY =====\n")
  # Add timestamp of the error occurring.
  f.write("Timestamp: " + str(datetime.datetime.now().strftime("%d.%b %Y %H:%M:%S")) + "\n")
  # Write the exception that occurred.
  f.write("Exception in {}".format(event_method) + "\n")
  f.write("===== TRACEBACK =====\n")
  # Print out the traceback of the error.
  f.write(traceback.format_exc() + "\n\n")

  # Once the file is created and all of the information
  # is printed, push it to Pushbullet.
  with open("error.txt", "r") as file:
    # Open the error log as a file
    # and push it to yourself.
    file_data = pb.upload_file(f, "error.txt")
  push = pb.push_file(**file_data)

No matter what approach you take, you should get a handy little file in your Pushbullet every time an error is thrown:

Conclusion

And that’s it! You’ve connected your Pushbullet account to your error handling in Python. Whether you’re a SysAdmin, or a bot developer like me, you will now be able to be notified whenever an error is caused, and get a nice text message with timestamp and a log to see what could have caused the problem. Since implementing this change, I have become much less paranoid, and now I can live my life knowing my code works in the background. Thanks for reading, and happy coding!

Java, The Carlos Way - Lesson 2

2019-06-11T00:00:00+00:00

Welcome back to Java, the Carlos Way! I hope my first lesson got your feet wet and your curiosity piqued enough to want to come back and learn some more. This time around, we’ll be going through some other basics, how to set up a development environment, and finally get your feet wet!

Previous Lesson

Your First Java Program

The time has finally come to program your first Java project. In the spirit of programming culture, the first program that we will write together will do a very simple thing: output the words Hello World!. This is many programmers’ first code, and it will be yours in a very short amount of time.

Try to follow along, not by copying and pasting, but by typing everything out. That way, you know exactly what you’re doing and you get a better feel for your programming environment.

Let’s dive right in:

Main.java

// First, we declare the class Main.
public class Main{
  // Next, we declare the function, main, inside Main.
  // "void" means that we will not be returning any values
  // At the conclusion of our function.
  public static void main(String[] args){
    // Next, we print out the words "Hello World!".
    System.out.println("Hello World!");
  }
} // Always check your brackets and semicolons!

More Java 101

We’ll need to learn a little bit more about what we’re doing in order to understand the code that we just typed. Bear with me, there will be more code coming soon!

Java Data Types

In Java, information is stored in a variety of types. a type is like a container of storage, and a limited amount of information fits in each of the storage containers. You want to be as storage-efficient as possible, so you’ll choose a smaller container if possible, if you know that your information won’t take up that much space, which makes your code faster and more efficient.

There are a lot of data types in Java, but I’ll just go through the most popular ones:

String
Integer
Double
Boolean

Quick Tip: Integers can be written as int interchangeably, which is why you’ll often see me substitute int for Integer!

String

A string is a datatype that represents an array of characters. These characters can be anything, from numbers, to letters, to emoji. Strings in Java are very powerful, and have many embedded functions that allow you to perform many operations. I often find myself casting (converting) other data types to Strings in order to perform specific operations on them, like getting the number of digits in a certain number, or getting the last n digits of a number/decimal. A drawback of this data type is that it takes up lots of memory space, and inability to perform arithmetic.

Integer

An integer is a much more lean data type, sitting at only 4 bytes. This means, of course, that it can store values from -2,147,483,648 to 2,147,483,647 - which, for most cases, should be enough for any numerical value. This data type contains all of the operations you think you’ll need, such as addition, subtraction, multiplication, and division.

Double

A double is very similar to an Integer, but it holds twice as many bytes (8). While this is more storage, and will take up more RAM, doubles have a unique capability - to store decimal values. Because it is impossible to store 1.5 into an Integer, the most used data type for this kind of value is a double.

Boolean

Perhaps the most useful data type is the Java boolean. This grants the ability to store binary values, namely True or False. You’ll be using these a lot of the time without even declaring them, as many functions in Java return a True when an operation is successfully completed.

Other Types

There are many other types that you might find yourself using when you become a more successful programmer and want to worry about memory allocation, such as:

short
long
float

Additionally, the classes you write yourself act just like data types, which you will learn more about later on. When we make functions, we will also be employing data types, as we can return them at the conclusion of our functions.

Declaring variables

Now that we know all about data types and what they store, let’s look into how to create them and use them in our code.

The general structure for declaring variables is as follows:

datatype variableName = value

datatype is the name of the datatype we are declaring.
variableName is the name of the variable that we will be using in the rest of our code.
value is the actual value being stored inside of the variable.

Now, let’s go through an actual example that we can use to rewrite our “Hello World” program:

public class Main{
  public static void main(String[] args){
    // We declare a new String called message that stores
    // the value "Hello World!"
    String message = "Hello World!";
    // We print out the message instead of the text.
    System.out.println(message);
  }
}
// Output: Hello World!

As you can see, the output is the exact same, but this time, we created a variable and printed it out instead of placing the content of the message inside of System.out.println();

Casting Between Data Types

Oftentimes you’ll find yourself wanting to convert between data types, such as from integers to Strings, as mentioned above, or between more abstract data types to Strings in order to visualize them easily. The process of converting a variable from one data type to another is called Casting.

The general format of casting from one type to another is as follows:

There are two kinds of casting:

Lossless Casting

Lossless casting is casting in which no information is lost. When an Integer is converted into a Double, no information is lost, because all of the integer’s values can be placed within the double. Here’s an example of that process:

/**
We first declare the variable, "num" as an integer,
and assign the value of 420.
**/
int num = 420;

// We print out the value that we just created.
System.out.println(num);
// Output at this point: 420

/**
We create a new double, "dec", and cast "num" to "dec".
**/
double dec = (double)num;

// We print out "dec".
System.out.println(dec);
// Output: 420.00

As you can see, no information is lost, because doubles can hold any and all values of integers.

Lossy Casting

Lossy casting involves converting an object of greater data capacity into one with less data capacity. For example, the reverse of the previous example would be considered a lossy cast, because a double is 8 bytes and an integer is 4 bytes, and information could be lost. Let’s show an example:

double dec = 420.69;

System.out.println(dec);
// Output: 420.69

// Information is lost because integers do not have decimals.
int num = (int)dec;

System.out.println(num);
// Output: 420

In the above example, you can see that the new integer we created did not have the decimal value that was after 420. It is important to remember that this occurs so that you will not make any mistakes in math or your code in general!

Quick Tip: By default and when casting, Java does NOT round up or down. It truncates, which means it just chops off whatever information it needs to from the numerical value.

Automatic Casting

Since lossless casting does not result in the loss of information, Java will do it automatically, if prompted for a datatype that is higher in storage than the one that is given. This actually happens all the time, most importantly for beginners when we use System.out.println();.

For instance:

System.out.println(11);
// 11 is being casted to a String and then printed out.
// Output: 11

Since System.out.println(); takes in a String as its parameter (the variable between the parentheses), Java automatically casts the integer to a String and then uses it as-is. This will also work with doubles, and the other data types I mentioned.

toString

Another form of automatic casting is what is called the toString() function. toString() is a function that is embedded by default in all classes, and is actually what is being called in the function above, and whenever we convert any of the default data type into a String. When we write a Class, which you will be doing a lot of later, you will also have the opportunity to write your own toString() function, and with that, you’ll be able to easily write text outputs for your functions.

Let’s try an example of a type that already exists though:

// Num is declared as an integer.
int num = 420;
// It is converted into a string with toString.
String numString = num.toString();
// A string is printed out.
System.out.println(numString);
// Output: 420

Summary

In this lesson, you learned:

The standard "Hello World!" Java program
Basic Java data types
How to print things to the Java console
Casting (Converting between data types)
- Lossy Casting (Data is lost)
- Lossless Casting (No data is lost)
Automatic casting
The toString function

Next time, we’ll go into creating Java projects in my favorite editor, VSCode, logical statements, and basic inheritance. Stay tuned!

10 VSCode Extensions Every CS Student Needs

2019-06-05T00:00:00+00:00

Are you a Computer Science student that’s just starting to kick off their interest for programming, or just downloaded VSCode because the code editor you were taught before college was last updated in the 90’s? No matter your situation, these Visual Studio Code extensions will get your feet wet in this new, futuristic IDE, and impress your fellow students.

10. Material Theme

These days, it seems like there’s an infinite amount of theme extensions for Visual Studio. Personally, I think the default dark theme is quite nice, but after a couple of months of programming I found myself wanting a little bit of a darker theme. Enter Material Theme. Right off the bat, it has several color schemes, and allows you to switch between them from a quick switch of the command palette, as well as select an accent color. The current configuration I’m using involves the base high contrast dark theme, with several settings changed within editor.tokenColorCustomizations to make it exactly the way I want it to be. Whether you want to heavily edit your theme, or just want something that looks great right off the bat, Material Theme is your best bet.

Download Material Theme

9. Code Spell Checker

Ever spill hours into your code without knowing what’s wrong, until you realize you spelled message as mesage in one part of code, which subsequently broke everything else? Code spell checker aims to prevent just that. It has support for multiple languages, and even allows you to have a custom dictionary for things like your last name or custom product names. It’s simple and straight to the point, but I don’t know what I would do without it (especially considering I blog inside of VSCode!)

Download Code Spell Checker

8. Rainbow Brackets

Gone are the days of having to count each bracket to make sure you have an even number, or trying to figure out which set of brackets is which. With Rainbow Brackets, you’ll instantly color your IDE with each pair of brackets and parentheses you employ in your code. I can’t say how much of a difference this lone extension has made in my development process - and I hope that you can have the same experience as well!

Download Rainbow Brackets

7. indent-rainbow

Following the vein of making our code editor colorful, another essential extension to my development process is indent-rainbow. This is also one of the extensions I installed early on in the beginning, and completely forgot that it was an optional extension because of how essential it became to my workflow. Especially when working with spaces for indentation, this extension will come in handy in telling you when you’re not using the correct number of spaces for a line, or to see whether you’re inside of a particular coding block when programming in an indentation-aware language, like Python.

Download indent-rainbow

6. Prettier - Code formatter

Prettier is one of the extensions that I didn’t know I was going to need when I switched over to VSCode from Eclipse and IntelliJ IDEA. Sometimes different programmers have completely distinct formatting preferences, and Prettier is an extension that aims to fix the problem in the best way. Instead of forcing you to follow a particular syntax, Prettier will standardize your language’s formatting with a simple right click command once you’re done programming. This is definitely useful when programming on a GitHub repo with a team or just to fix programming errors to make your code look a lot more professional. Give it a shot - you never know when it might come in a pinch!

Download Prettier - Code formatter

5. Vim

Now, this sounds like an unconventional addition to the list, doesn’t it? Hear me out – using a mouse/touchpad is boring. Why not use decades’ old technology anew and navigate the entirety of your code editor with your keyboard! I stumbled upon this extension when I was learning Unix editors for class, and figured I’d kill two birds with one stone and practice my Vim skills while doing my other programming work. Pretty neat, huh? If you like Vim (Which is admittedly pretty rare nowadays), be sure to check it out!

Download Vim

4. Discord Presence

This extension, while not necessarily falling into the “productivity” category, is definitely interesting to use, because I am a frequent user of Discord. Where this extension comes in handy is that it will actually fill in your discord presence indicator to show what project you’re working on, how much time you have elapsed on it, and more, with a highly customizable interface. Definitely give it a try if you’d like to show how much of a dedicated programmer you are to your Discord friends!

Download Discord Presence

3. vscode-spotify

When I discovered that this extension existed, I realized that VSCode was not a code editor do be reckoned with. If programmers are able to implement every feature you’ve never thought of, even an in-editor Spotify controller, then it’s definitely something worth giving a shot. Ever since I downloaded one of the first public versions of this extension, I’ve never gone back. when “in the zone”, you don’t want to be held back and waste precious seconds by having to tab into your Spotify player to change the song. Instead, you can do so through your handy status bar in the bottom of the editor. Better yet: be a pro and assign music controls to commands using your keybinding settings. Give it a try and never tab out for music again!

Download vscode-spotify

2. Better Comments

Now nearing towards the end of our list, come some of the most remarkably useful extensions that VSCode has. Enter better comments. Ever want to distinguish your TODO comments, your DEBUGs, or more? Look no further than this extension! It is completely customizable to fit any colors you want to use, and has extremely useful functions such as displaying commented out code as crossed out and greyed out so you can focus on what matters. This one is worth digging into its configurations for, however - so don’t hesitate to get your hands dirty in config.json!

Download Better Comments

1. Code Runner

One of the biggest drawbacks I initially experienced when making the switch from traditional IDEs to the more “text-editor” style VSCode was the ability to click run, or use a quick keybinding to run my current program. This was actually something that prevented me from making the switch to VSCode for an entire year, after my colleagues repeatedly suggested using it, but were not able to respond how to run code in place without having to open a terminal. Code Runner is also extremely customizable, and supports both WSL and the Command Prompt, regardless of your desired programming environment. It also supports practically any language you’ll be programming in. You are supplied with several commands in the command palette, and also a run button on the top right of your editor to run your code when the language is supported, which incredibly speeds up debug and testing time. Give it a try!

Download Code Runner

Conclusion

I hope you’ve found these extensions to be useful. All of these are extensions I inevitably find myself using every single day I program, and hope you are able to make your programming experience more pleasurable and easier through these and other extensions. Let me know in the comments below if you have any extension recommendations, I’m always excited to try to find new workflows for my code editor!

Until next time!

Java, The Carlos Way - Lesson 1

2019-06-04T00:00:00+00:00

Welcome to Java, the Carlos Way! Over the course of this series, I’m going to try to teach you Java in the easiest way possible. There’s a lot of content, so be sure to take things slowly and at your own pace. I’ll do my best to link to a lot of different tutorials for more in-depth review. Now that I’ve got your attention, let’s get started!

Why This Exists

When I was 12 years old, I decided to tackle my first programming language, Python. I did so without any prior knowledge, without any formal textbooks or teachers: completely on my own. In the same way that I was able to learn from volunteers for free and on blogs and YouTube sites from people around the world, so too I want to impart my knowledge. I hope you are able to learn a great deal from this, and if you do, please consider passing on what you learn as a programmer. Soon, we will make the world full of people who know programming!

Now, let’s get started…

Java 101 (The Boring Stuff)

I call this “The Boring Stuff” because I know you want to get dirty with code! However, there are some central things you must understand before jumping into a development environment and writing code…

What Is OOP?

OOP, or Object Oriented Programming, is a method of programming in which a programmer writes classes, and functions for those classes, and develops a hierarchical structure in order to achieve his or her programming goals. There are many different programming languages: Python, Java, C++, and more, and each has their own separate use case. Java is primarily used for developing cross-platform applications, or programs that can run on more than one system, such as Android, Windows, Mac, and iOS.

The Java Hierarchy

In Java, as well as in other programming languages, there is a general hierarchy that dictates the way we use the language.

I have created a handy diagram in order to illustrate the Java Hierarchy:

Levels of Hierarchy

The levels of hierarchy go as follows:

Packages
- A package is the highest level that can be imported into a Java program. Some of the most popular Java packages are:
  - Java.util
  - Java.lang
- Every class in Java is contained into packages.
- It is possible to create your own package when designing a project, but this is only recommended when it is a very big project and requires developing entire classes from scratch.
- Package names are denoted by a lowercase letter.
Classes
- Classes are contained within packages, and are usually the most often written by programmers when designing a program.
- Some popular Java classes are:
  - Java.lang.Math
  - Java.util.Random
- Class names should begin with a capital letter.
Objects
- Objects are what we call instances of a class, in which one instantiates a class in order to use it in our program. Instantiating is like “materializing” it, and allows us to use its member functions/variables.
Code (Functions and Variables)
- Inside of every class lie functions and variables that are relevant to its name. Though there may be many instances of a single class, it is these member functions and variables that separate them from each other.
- Member functions use camelCase, which will be explained later.

The Java API

The Java API is the number one website you’ll be referencing and bookmarking throughout your studies. It contains the list of all of the packages, classes, objects, and methods that are embedded into the base version of Java that is shipped onto millions of devices. Few languages have as good a documentation as Java, which is why it’s a favorite for many programmers.

Syntax

What distinguishes Java from any other language its syntax. Just like any written language, programming languages each have their own set of syntax, and to learn the syntax by heart and to be able to use it seamlessly is truly to know the programming language. There are two categories to programming syntax:

Syntax that the language interprets.
- This has to be exact, or else the computer will not know what telling it to do.
Syntax that is used by programmers to make it readable to other programmers.
- This is not technically necessary, but a good programmer will always use common programming conventions.

In this course, we’ll be going over both of these.

CamelCase

One of the most important building blocks of naming structures in Java is the use of camelCase. Whether working with classes or variables, the way we distinguish between words in Java is using camelCase. This practice involves capitalizing the first letter of each word that’s composed in the Class, variable or method name. Here are a couple of examples:

Class Name
- public class DogFood
- Right off the bat, even without seeing the class declaration, we already know it is a class because it begins with a capital letter.
- This follows the convention explained above, which is why this is so important.
Variable/Method Name
- public void getFood(){}
- Since this method name begins with a lowercase, we already know that it is either a variable or a method.
- This is also in accordance with the levels of hierarchy conventions.

Technically, the Java compiler doesn’t care about your naming conventions, but using them will help you and others reading your code to understand what you’re doing. This is something I started off not caring about, and I had to learn to do it the hard way, because I ended up not being able to understand my own code. Don’t be a Carlos!

Brackets, Parentheses, and Semicolons

Another important element of Java is the use of brackets and parentheses. Almost all programming languages use these in one form or another, but the ones in Java are particularly essential because that is the way that Java knows what you are writing.

Brackets

All content inside of a class or function is placed inside of brackets.
There are always an even number of brackets in any code that will correctly compiled.
Always count your brackets to make sure you have the correct number!

Parentheses

Parentheses can be used to separate arguments when using arithmetic.
In methods, parameters are placed inside of parentheses, whether defining or calling the function.
There should also always be an even number of these, so be sure to count them!

Semicolons

Semicolons are placed at the end of every “code” function, or when calling a method.
Semicolons do not have to go on lines where you are opening or closing a class or method definition, or where there is a bracket.

Example (Putting it all together)

Here is a small example of code you’ll be able to understand soon, that implements everything that you learned today! We’ll go into more detail about everything in the snippet as you learn more about Classes and the generic Java program.

import java.util.*;

public class Dog{
  public void bark(int noise){
    makeSound(5);
  }
}

Next time, we’ll go into the use of data types, programming environments, and finally start your first program!

Next Lesson