Category: Manageable Monday
Walk through manageable ways to understand complex computer science and development topics.
Practical Machine Learning with Ruby
The following outline is a talk I gave at the Utah Ruby Users Group (URUG) where I discussed machine learning and how it can be applied in the Ruby programming language. It has also been updated for the talk I gave to the AZ Ruby Users Group where I added the Naive Bayes implementation. What is Machine Learning? TechTarget Definition “Machine learning is a type of artificial intelligence (AI) that provides computers with the ability to learn without being explicitly programmed. Machine learning focuses on the development of computer programs that can teach themselves to grow and change […]
Introduction to Conditionals for Developers
You won’t get very far in your study of algorithms before coming across conditionals. And in fact, in our previous guide on boolean logic we already introduced ways to implement conditionals. So in this guide we’re going to take a deep dive into how we can use conditionals to build algorithms. What are Conditionals? First and foremost, what are conditionals? The easiest definition I could come up with that still expresses the goal of conditionals is: A conditional is a computer science process that allows for a program to make dynamic decisions based on answering […]
Developer Guide to Boolean Logic
In this guide I’m going to discuss one of the most fundamental concepts in the world of computer science: boolean logic. Despite its importance, many developers have shelved topics such as boolean logic to the archives of boring math concepts. However, the concept of boolean logic is used so often in programming, that it’s a mistake to ignore it. Boolean Logic Definition From a programming perspective, boolean logic is: The concept of breaking complex decisions down into a series of true and false questions. Essentially every time you utilize an if/else conditional in a program, […]
Guide to the Set Data Structure for Developers
When it comes to the full list of data structures, the Set data structure is one of my favorite topics. Even though sets are in the category of abstract data structures, you’ll discover that they’re quite practical. And in this guide we’ll walk through a number of ways that sets can be used in real world programs. Set Data Structure Set Definition and Rules So what exactly is a Set? A set is a data storage tool that follows a number of rules: From a storage mechanism perspective, sets do not have to be in a specific order. […]
Guide to the Hash Data Structure
No course on data structures would be complete without discussing the topic of hashes. The reason for this is because hashes are used constantly in the software development world. Hash in Ruby Development Before we dive into hashes, I want to give a warning. If you are coming from a language, such as Ruby, you may believe that you’re already familiar with hashes because of the Hash data type. Language such as Ruby have a key/value pair data structure called hashes. However you will quickly discover that computer science based hashes are a bit more […]
Algorithm Guide: Tree Data Structure Terminology
Before we walk through how the tree data structure can be utilized to manage data, there are some key terminologies you should become familiar with. This guide walks through each of these terms. You can use this guide as reference/cheat sheet for the tree data structure terminology. Root Definition: The very top node of a tree. Child Definition: Any node connected to another node, while moving away from the root node. Parent Definition: A node that contains child nodes Siblings Definition: Multiple nodes connected to the same parent node. Leaf Definition: A node with no child […]
Do You Have to Be a Genius to Be a Developer?
We’ve discussed the topic of whether great developers are born or made. And in this guide we’re going to look at a similar topic from a different angle. And we’re going to answer the question: do you have to be a genius to be a developer? Because of the near magical nature of coding, one of the most common remarks I hear from individuals who hear what I do is: “Oh wow, you’re so smart!” In fact, just recently I traveled to meet with a group of developers and the head of the company introduced me by […]
A Practical Process for Understanding the Heap Data Structure
When it comes to understanding tree data structures, one of the most straightforward tree types is the Heap data structure. I like heaps for a number of reasons, namely: It’s typically clear when heaps should be used in a program. You can spot in an instant if a data structure is a heap or not by following a few rules. Heap Data Structure Requirements When it comes to working with Heaps there are two main Heap types: Max heap Min heap We’ll be using Max heaps for our examples in this guide. In order to […]
Tree Data Structure Introduction – A Practical Guide to Trees
In the last few weeks on CronDose we’ve discussed data structures. Specifically we’ve walked through: arrays, linked lists, stacks, and queues. Those structures are all in the linear family of data structures. This guide will introduce another type of data structure type: the tree data structure. At the end of the day you will need to utilize tools such as arrays and linked lists in order to work with trees. So trees are not as much an alternative structure, instead they are a way of implementing and thinking about how data is organized. This is mainly because trees […]
Understanding the Stack Data Structure – A Guide to Algorithms
When it comes to working with abstract data structures there are two components that need to be understood: Queues and Stacks. In this guide walks through understanding the Stack data structure. Real World Example of Stacks As we spoke about previously in regards to the Queue data structure, it functions like a line at an amusement park. The first elements that go into the structure are also the first elements that come out. When it comes to understanding the stack data structure there is another helpful real world analogy. Stacks work in the exact opposite way that queues do. […]