A while ago, we wrote about a command line virtual assistant named “Betty”. Today, I stumbled upon a similar utility called “Yoda”. Yoda is a command line personal assistant who can help you to do...

Suplemon is an open source, modern, powerful, intuitive and feature-rich command-line text editor with multi cursor support; it replicates Sublime Text like functionality in the terminal with the use of Nano.

ddgr is a command-line utility to search DuckDuckGo from the terminal. ddgr works out of the box with several text-based browsers if the BROWSER environment variable is set.

Make sure your system should have installed any text-based browsers. You may know about googler that allow users to perform Google searches from the Linux command line.

It’s highly popular among cmdline users and they are expect the similar utility for privacy-aware DuckDuckGo, that’s why ddgr came to picture.

Unlike the web interface, you can specify the number of search results you would like to see per page.

Suplemon is a CLI text editor that offers modern features like multi cursor support, keeping the simplicity and ease-to-use of a console text editor.

Looking for a quick, easy, and secure method to protect your files? Well, there is a simple shell utility called “Cryptr” that helps you to encrypt and decrypt files. All from command line, and you...

Minilens is a fun open source puzzle-platform game set on post-apocalyptic Earth. The star of the show is Minilens, a robot that lacks the ability to jump. His task is to cleanse Earth of radioactive barrels, and at the same time collect the only life left on the planet — flowers.

This article focuses on using a Deep LSTM Neural Network architecture to provide multidimensional time series forecasting using Keras and Tensorflow - specifically on stock market datasets to provide momentum indicators of stock price.

The following article sections will briefly touch on LSTM neuron cells, give a toy example of predicting a sine wave then walk through the application to a stochastic time series. The article assumes a basic working knowledge of simple deep neural networks.

I recently wrote a Markov chain package which included a random text generator. The generated text is not very good.

The rest of this post covers the evolution of the main algorithm.

CLIs are a fantastic way to build products. Unlike web applications, they take a small fraction of the time to build and are much more powerful. With the web, you can do whatever the developer programmed. With CLIs, you can easily mash-up multiple tools together yourself to perform advanced tasks. They require more technical expertise to use, but still work well for admin tasks, power-user tasks, or developer products.

At Heroku, we’ve come up with a methodology called the 12 factor app. It’s a set of principles designed to make great web applications that are easy to maintain. In that spirit, here are 12 CLI factors to keep in mind when building your next CLI application. Following these principles will offer CLI UX that users will love.

We’ve also built a CLI framework called oclif that is designed to follow these principles to build great CLIs in Node.

For quite some time I’ve wanted to record a new video talking about code comments for my "writing system software" series on YouTube. However, after giving it some thought, I realized that the topic was better suited for a blog post, so here we are. In this post I analyze Redis comments, trying to categorize them.

Along the way I try to show why, in my opinion, writing comments is of paramount importance in order to produce good code, that is maintainable in the long run and understandable by others and by the authors during modifications and debugging activities.

The Fibonacci numbers are the sequence 1, 1, 2, 3, 5, 8, ..., and satisfy the recurrence F(n) = F(n – 1) + F(n – 2).

They also have a beautiful formula.

My favorite derivation of this formula entirely avoids algebraic manipulation.

Roughly speaking, Gödel’s Incompleteness Theorem states that there are true mathematical statements that cannot be proven. When I was in 11-th grade, my geometry teacher Mr. Olsen, my friend Uma Roy, and I spent five weeks reading through Gödel’s original proof of the theorem. Why did it take so long? Partly because Uma and I were high-school students. Partly because Gödel was a less-than-talented writer. But mostly because the proof is actually pretty hard.

Sharing files can be a pain. The larger the file is, the more difficulty it inevitably creates. If you want those files kept private, you're in for a real nightmare. Well, not exactly.

Onionshare is a relatively new application that allows you to share files of any size securely and relatively anonymously over the Tor network without the need for a "midde-man" website. It's completely free and open source, and it's actually easy for anyone to use.

Human activity recognition is the problem of classifying sequences of accelerometer data recorded by specialized harnesses or smart phones into known well-defined movements.

It is a challenging problem given the large number of observations produced each second, the temporal nature of the observations, and the lack of a clear way to relate accelerometer data to known movements.

Classical approaches to the problem involve hand crafting features from the time series data based on fixed-sized windows and training machine learning models, such as ensembles of decision trees. The difficulty is that this feature engineering requires deep expertise in the field.

Recently, deep learning methods such as recurrent neural networks and one-dimensional convolutional neural networks, or CNNs, have been shown to provide state-of-the-art results on challenging activity recognition tasks with little or no data feature engineering.

In this tutorial, you will discover the ‘Activity Recognition Using Smartphones‘ dataset for time series classification and how to load and explore the dataset in order to make it ready for predictive modeling.

I’ve almost never been able to write correct Python import statements on the first go. Behavior is inconsistent between Python 2.7 and Python 3.6 (the two versions that I test here), and there is no single method for guaranteeing that imports will always work.

This post is my dive into how to resolve common importing problems. Unless otherwise stated, all examples here work with both Python 2.7 and 3.6.

Decision trees are the fundamental building block of gradient boosting machines and Random Forests(tm), probably the two most popular machine learning models for structured data. Visualizing decision trees is a tremendous aid when learning how these models work and when interpreting models. Unfortunately, current visualization packages are rudimentary and not immediately helpful to the novice. For example, we couldn't find a library that visualizes how decision nodes split up the feature space. So, we've created a general package (part of the animl library) for scikit-learn decision tree visualization and model interpretation.

It’s hard for me to teach an in-depth Python class without discussing lambda expressions. I almost always get questions about them. My students tend to see them in code on StackOverflow or they see them in a coworker’s code (which, realistically, may have also come from StackOverflow).

I get a lot of questions about lambda, I’m hesitant to recommend my students embrace Python’s lambda expressions. I have had an aversion to lambda expressions for many years, and since I started teaching Python more regularly a few years ago, my aversion to lambda expressions has only grown stronger.

I’m going to explain how I see lambda expressions and why I tend to recommend my students avoid using them.

In their hearts, computers are sequential beasts. Their power comes from being able to break down the largest tasks into tiny steps that can be performed one after another. Often, though, our users need to see things occur in a single instantaneous step or see multiple tasks performed simultaneously.

A typical example, and one that every game engine must address, is rendering. When the game draws the world the users see, it does so one piece at a time — the mountains in the distance, the rolling hills, the trees, each in its turn. If the user watched the view draw incrementally like that, the illusion of a coherent world would be shattered. The scene must update smoothly and quickly, displaying a series of complete frames, each appearing instantly.

Double buffering solves this problem, but to understand how, we first need to review how a computer displays graphics.

🙀 A cat explains how HTTPS works...in a comic! 😻

The second article in our series on privacycoins looks at Monero. One of the oldest privacycoins on the market, it's based on the innovative CryptoNote protocol first used by Bytecoin.