In this interview, Tommy Caruso shares with us his strategy of balancing a family, kids, finishing up his Computer Science degree, and Launch School all at the same time. Oh, and he’s also interning in his spare time. We had a great time chatting about time management, study habits, and the sacrifice it takes to really learn things to depth. Listeners may also be interested in his take on comparing his Computer Sciences courses with that of Launch School.
One of our students, Karl Lingiah, took time to answer some questions and talk about his journey so far at Launch School. He shares his ideas on learning in general, and specifically what his experience has been so far at Launch School.
Note: we had a sub-optimal internet connection, so the audio is not the best, but the full talk is still worth a listen.
One of the biggest keys to producing quality software is properly testing your program under a wide variety of conditions. Doing this manually is tedious and error-prone, and frequently doesn’t get done at all. This leads to buggy software, and sometimes software that doesn’t work at all.
Fortunately, modern programming environments support automated tests. Such tests can be run repeatedly with minimal effort: it’s even possible to run them automatically prior to every commit or release. While automated testing doesn’t guarantee that your code will be bug free — the tests are only as good you make them — it can certainly reduce the number of bugs your users will encounter. Automated testing can also help you find and fix bugs earlier in the development cycle, and prevent a lot of needless debugging trying to track down a particularly nasty bug.
In this post, we will talk about Minitest, the standard software testing framework provided with Ruby. It isn’t the only software testing framework available, but being supplied automatically with Ruby is a major advantage.
In particular, we will discuss how to use Minitest assertions to test your software. We aren’t interested so much in the theory of automated testing, but in how to use Minitest.
This is the last in a series of three articles that discuss how ruby manipulates variables and objects, and, in particular, how objects are passed around in a ruby program. If you haven’t read the first two articles, you may want to check them out first: Understand Variable References and Mutability and Ruby’s Mutating and Non-Mutating Methods.
We now have a good grip on how ruby uses variables to reference objects, what the terms mutability and immutability mean, and what it means for a method to be mutating or non-mutating. We’ve also been briefly introduced to the concept of object passing, and have established an initial mental model that states that ruby appears to use pass by value for immutable objects, and pass by reference for mutable objects. We’ve also established that assignment does not mutate objects but instead binds variables to new objects, while setter methods and indexed assignment do mutate objects.
You might have noticed that we’ve been careful to say “appears to use” instead of “uses”; there’s a good reason for this, which we’ll illuminate below.
This is the second in a series of three articles that discuss how Ruby manipulates variables and objects, and, in particular, how objects are passed around in a Ruby program. In the Understand Variable References and Mutability article, we explored how Ruby uses variables — variables don’t actually contain values, but instead serve as references to objects. We also discussed the concepts of object mutability and immutability, and introduced the concepts of pass by value and pass by reference.
In this article, we discuss methods, and how they can be mutating or non-mutating with respect to certain arguments. We focus special attention on assignment and concatenation, two operations that cause a lot of confusion for new rubyists.
This is the first in a series of three articles that discuss how Ruby manipulates variables and objects, and, in particular, how objects are passed around in a Ruby program. You can find many such discussions in articles that attempt to answer the question “Is Ruby pass by reference or pass by value?” Our goal in this series isn’t necessarily to answer this question — though we will provide an answer, of sorts — but to put that question in the context of how Ruby actually works.
The answer to the question really isn’t that important. What is important is more fundamental: knowing how Ruby works. A proper understanding of how Ruby works will take you much further than being able to provide an answer to the question; it will help you learn to anticipate what Ruby will do, when it will do it, and why it will do it. This will help you become a better Ruby programmer, and reduce the number of bugs you encounter due to unexpected behaviors.
In this article, we start out by exploring how Ruby variables and objects are connected to each other, and the part that mutability or immutability of objects plays when manipulating variables. We will also introduce the concepts of pass by reference and pass by value, but a more detailed discussion will be postponed until the article Object Passing in Ruby – by Reference or by Value.
Every company has a “secret sauce” that makes them unique. Every company, big or small, embraces one core attribute that makes them stand out. Here at Launch School, that one unique attribute is our 100% commitment to a Mastery Based Learning approach.
We put comprehension and mastery above all else, and it’s how we can promise every single person who comes to us the skills for a long career as a software developer. But, there are some tradeoffs with this approach, too.
Watch the recording to this webinar to find out what a 100% Mastery Based Learning program looks like, and what the tradeoffs are. We’ll explain how we teach, what the learning process will be like, and also cover the downsides of this approach.
It’s often difficult to prescribe a “right way” for a beginner to learn programming because everyone learns differently. But there are certainly wrong ways to learn. Over the years, we’ve seen many learning anti-patterns. In this webinar, we’ll talk about many of them and how to avoid them. This webinar is geared towards those who haven’t started the Launch School program yet, or those who are very early in the process.
This is the fourth part of our Watch Others Code webinar series. In this session, we had a student volunteer work through a few exercises:
- calculate number of Friday the 13ths in a year
- generate random English mathematical phrases
Watch the full video below (around an hour).
This is the third part of our Watch Others Code webinar series. In this session, we had a student volunteer work through a few exercises:
- convert english phrase into a mathematical expression, step by step
Watch the full video below (around an hour).