9.3
3 votes
Clean Code

Clean Code

2011

Clean Coders is all about educational videos for software professionals, by software professionals.Clean Coders code-casts are rich with content and will forever change the way you think about code, about design, about your disciplines, about your profession.

Watchlist All running TV shows Watchlist Watchlist Watchlist Watchlist Watchlist Watchlist Watchlist Watchlist

The 10 Best Episodes of Clean Code

#1 - Screencast III: Video Store

10.00

Season 1 - Episode 11

This is the famous "Video Store" example from Martin Fowler's wonderful book: Refactoring. In this hour-long screencast, Uncle Bob (UB) takes it apart one step at a time. In the end, he will transform this code from a single large function in a group of otherwise empty classes, into a nicely partitioned object oriented design. UB will tear this code apart, and turn it inside out. He'll use a wide-range of refactoring in order to chop the code up and drag the fragments into the classes that need them. In the process the tests will be cleaned up, the Single Reponsibility Principle will be enforced, three new classes will be created and populated, and the result will be a much cleaner module. You don't want to miss this one!

The episode was rated #1 Best episode of Clean Code from 1 votes.

#2 - Screencast IV: Stack

10.00

Season 1 - Episode 12

This is the main screencast for Clean Code Episode IV - Function Structure. In this screencast Uncle Bob (UB) performs the famous Stack kata, developing a simple Stack data structure driving with tests all along.

The episode was rated #2 Best episode of Clean Code from 1 votes.

#3 - The Single Responsibility Principle

10.00

Season 2 - Episode 2

In this video Uncle Bob will take you on a deep dive through the Single Responsibility Principle. After a little General Relativity, you'll learn just what a responsibility is, and how it relates to the users of the system and the roles that they play. You'll learn about the primary value of software, and why that value is not what you'd expect. You'll also learn how the proper allocation of responsibilities to modules impacts that value and means increased profits for your business. Uncle Bob will teach you how misplacing responsibilities can lead to design smells like Fragility and Viscosity. He'll show you the importance of separating responsibilities into different functions, classes, and modules. And he'll demonstrate different techniques for achieving that separation. Next, he'll walk you through several different Java functions and ask you to find the single responsibility violations. Then he'll show them to you and recommend ways to separate them. Finally, he'll walk you through the case study of a simple application, from inception to delivery. He'll show you how to find the responsibilities; and, following the principles of architecture from Episode 7, how the system can be designed so that those responsibilities are separated. He'll also show you where to get the code so you can study it later. So get yerselves saddled up and rarin' to go because yall're 'bout to stampede into The Single Reponsibility Principle. Yee Ha!

The episode was rated #3 Best episode of Clean Code from 1 votes.

#4 - The Open Closed Principle

10.00

Season 2 - Episode 3

The Moral Center of Software Architecture. That's how Uncle Bob describes the Open-Closed Principle (OCP). In this episode you'll learn all about Bertrand Meyer's remarkable insight into Object Oriented Design and the motivation behind good Software Architecture. We'll discuss how it's possible for the source code of a system to be open for extension, but closed for modification. Then we'll show you how to construct designs that conform to that principle. Next we'll look at a truly awful design that violates the OCP and we'll show how that violation creates the design smells of Rigidity, Fragility, and Immobility. Then we'll present a truly elegant and beautiful design that conforms to the OCP. This design will startle you with it's essential simplicity; dazzle you with it's suave construction; enamor you with it's incredible flexibility. After seeing it, you'll begin to believe that software can be open for all extension and yet closed for all modification! Then we'll break your heart by showing you why the promise of the OCP is, in fact, a big lie. We'll tear that elegant design to shreds, and we'll show you why all that protection it claimed to offer was an illusion that depended upon prescience and perfect foresight. In the end we'll shatter your hopes and dreams in software design. Then we'll resurrect those hopes and dreams by describing a development process that helps to restore the truth behind the promise of the OCP. We'll show you that you can, in fact, make designs that conform to the OCP, if not in whole, then at least in part. We'll describe the disciplines that will help you to take the greatest advantage of the OCP. So sit yourself down and settle on in, because after we learn about the Quantum Discontinuity, we're going to open the can of worms called the Open Closed Principle.

The episode was rated #4 Best episode of Clean Code from 1 votes.

#5 - The Liskov Substitution Principle, Part 1

10.00

Season 2 - Episode 4

Oh no! Not the Liskov Substitution Principle! Not that! Please! Anything but squares and rectangles and type and subtypes. Katie, bar the door! Mabel, hide the kids. Somebody run for the Marshall. Tell him: LSP is coming! That's right, in this episode (after a brief diversion through wave/particle duality) Uncle Bob takes on the dreaded Liskov Substitution Principle. He'll tell you all about the history of the theory of types, including Russell's paradox, and Turing's revelations. He'll show how this theory influenced early computer languages like Algol, Fortran, Cobol, and even C++. Then Uncle Bob will introduce you to Barbara Liskov, and the principle of substitutability that she wrote about back in 1988. He'll describe that principle in terms of modern languages like Java and Ruby, and he'll show how it relates to Martin Fowler's code smell of "Refused Bequest". Then he'll dive into the favorite old conundrum of the squares and rectangles, and he'll show that inheritance is not what it appears to be, and certainly not what you have been told it is. He'll teach you about the Principle of Representatives and the implications it has for sub-typing and inheritance. And you Ruby programmers won't get off scott free either! He's got plenty to say to you about subtypes in dynamic languages. Next, Uncle Bob will show you the cost of violating the LSP and will present heuristics and techniques for identifying potential violations, and for correcting existing violations. On the way he'll talk about the dreaded 'if instanceof' statement. He'll show why it is dangerous, and when it is appropriate. Then, true to form, Uncle Bob will present a case study of a subtle LSP failure, and the horrific consequences it causes. You won't want to miss this part. By the time he's done you'll be hunting all through your code trying to find and repair potential LSP violations in order to prevent all the nasty 2AM phone calls you will otherwise receive. So let the horses o

The episode was rated #5 Best episode of Clean Code from 2 votes.

#6 - The Liskov Substitution Principle, Part 2

10.00

Season 2 - Episode 5

This is Part 2 of Episode 11 Oh no! Not the Liskov Substitution Principle! Not that! Please! Anything but squares and rectangles and type and subtypes. Katie, bar the door! Mabel, hide the kids. Somebody run for the Marshall. Tell him: LSP is coming! That's right, in this episode (after a brief diversion through wave/particle duality) Uncle Bob takes on the dreaded Liskov Substitution Principle. He'll tell you all about the history of the theory of types, including Russell's paradox, and Turing's revelations. He'll show how this theory influenced early computer languages like Algol, Fortran, Cobol, and even C++. Then Uncle Bob will introduce you to Barbara Liskov, and the principle of substitutability that she wrote about back in 1988. He'll describe that principle in terms of modern languages like Java and Ruby, and he'll show how it relates to Martin Fowler's code smell of "Refused Bequest". Then he'll dive into the favorite old conundrum of the squares and rectangles, and he'll show that inheritance is not what it appears to be, and certainly not what you have been told it is. He'll teach you about the Principle of Representatives and the implications it has for sub-typing and inheritance. And you Ruby programmers won't get off scott free either! He's got plenty to say to you about subtypes in dynamic languages. Next, Uncle Bob will show you the cost of violating the LSP and will present heuristics and techniques for identifying potential violations, and for correcting existing violations. On the way he'll talk about the dreaded 'if instanceof' statement. He'll show why it is dangerous, and when it is appropriate. Then, true to form, Uncle Bob will present a case study of a subtle LSP failure, and the horrific consequences it causes. You won't want to miss this part. By the time he's done you'll be hunting all through your code trying to find and repair potential LSP violations in order to prevent all the nasty 2AM phone calls you will otherwise

The episode was rated #6 Best episode of Clean Code from 1 votes.

#7 - The Interface Segregation Principle

10.00

Season 2 - Episode 6

And now, at last, it's time for the Dependency Inversion Principle -- the final principle in the SOLID suite. Go back in time with Uncle Bob to 1979, when he was just a noobie software developer with only 6 years experience. Walk with him through the tale of telephone test equipment using 8085 microprocessors with 32K of RAM and 32K of ROM. See how he first discovered the magic and power of inverting source code dependencies in order to turn those ROM chips into independently deployable components. Then hop into the time machine to the early '90s when Uncle Bob was becoming an accomplished C++ programmer. See how he, and his team, struggle, and at first fail, to create a huge reusable framework. Watch as he discovers the key to reuse, and to building frameworks that many applications can reuse. In this episode we'll learn what dependencies are. We'll study the difference between source code dependencies, and runtime dependencies. We'll learn why that difference is important, and we'll learn how to invert certain key source code dependencies so that they oppose their corresponding runtime dependencies. Then we'll spend some time looking at two case studies. First we'll look at IO drivers, and how they use dependency inversion to create device independence. Then we'll look at the good old furnace example, and see how dependency inversion allows us to separate high level policy from low level detail in order to create a plug-in architecture. So get ready for a wild ride through time and technology and we DIP in to the Dependency Inversion Principle.

The episode was rated #7 Best episode of Clean Code from 1 votes.

#8 - The Dependency Inversion Principle

10.00

Season 2 - Episode 7

And now, at last, it's time for the Dependency Inversion Principle -- the final principle in the SOLID suite. Go back in time with Uncle Bob to 1979, when he was just a noobie software developer with only 6 years experience. Walk with him through the tale of telephone test equipment using 8085 microprocessors with 32K of RAM and 32K of ROM. See how he first discovered the magic and power of inverting source code dependencies in order to turn those ROM chips into independently deployable components. Then hop into the time machine to the early '90s when Uncle Bob was becoming an accomplished C++ programmer. See how he, and his team, struggle, and at first fail, to create a huge reusable framework. Watch as he discovers the key to reuse, and to building frameworks that many applications can reuse. In this episode we'll learn what dependencies are. We'll study the difference between source code dependencies, and runtime dependencies. We'll learn why that difference is important, and we'll learn how to invert certain key source code dependencies so that they oppose their corresponding runtime dependencies. Then we'll spend some time looking at two case studies. First we'll look at IO drivers, and how they use dependency inversion to create device independence. Then we'll look at the good old furnace example, and see how dependency inversion allows us to separate high level policy from low level detail in order to create a plug-in architecture. So get ready for a wild ride through time and technology and we DIP in to the Dependency Inversion Principle.

The episode was rated #8 Best episode of Clean Code from 1 votes.

#9 - Advanced TDD, Part 1

10.00

Season 4 - Episode 1

OK, so I completely blew it. For a year now I've been promising you this episode on advanced TDD. Tease, tease, tease -- advanced TDD. Blah, blah blah. So then, when I finally started writing the script for the episode, I realized that the script was far too long for one episode, and I wasn't even halfway done with the topics I wanted to cover! So, I backed off and did a topic analysis on what I wanted to talk about, and found I had three or four episodes worth of material. I gathered the first topics together, and set the others aside for later. And then I finished off the script for the first episode. Then, after shooting and editing, we realize that the episode is two hours long! Woah! We need to split it again! So, here it is. Episode 19, part 1. Advanced TDD. In this episode we're going to do a deep dive into the three laws of TDD; with lots of code examples. We'll study the process of TDD in minute detail as we gradually build a simple program to invert names. As we explore the three rules, we'll also start the discussion about The Single Assert Rule; and then we'll set that aside for more exploration in a future episode. So, wash your eyes out and clean your glasses, because this one's all about the code. And get ready for the first half of Episode 19. Part 1. Advanced Test Driven Development.

The episode was rated #9 Best episode of Clean Code from 1 votes.

#10 - Advanced TDD, Part 2

10.00

Season 4 - Episode 2

So you've watched Part 1, right? I mean, you don't want to start with Part 2 because you'll miss all the preliminary discussion on the three laws. So, just checking. Part 2 is where things really start to get interesting. First we look at the topic of incremental algorithmics; the notion that you can derive an algorithm, one step at a time, by posing a failing test, and then making that test pass. As part of this process we'll learn one of the most foundational principles of Test Driven Development. The principle where the magic really comes from. As the tests get more specific, the code gets more generic. And then... and then... Well, then we go and get ourselves stuck; Stuck is a technical term that means: Stuck. In TDD when you are stuck, it means that in order to make the currently failing test pass, you've got to implement the whole program. It means there's no incremental step to take, no simple solution, no easy path. So first we show you how to get stuck -- because there's nothing quite so informative (and fun) as watching Uncle Bob fail. Then, we back up and show you how to get unstuck, and how to avoid getting stuck in the first place. And then we're done. Uh. Well. With Episode 19. But that's just the first of many episodes we're going to do on Advanced TDD. So, keep watch for more.

The episode was rated #10 Best episode of Clean Code from 1 votes.

#11 - Mocking, Part 1
10.00
Season 4 - Episode 6

EGAD! Another two-part episode! I just can't seem to get this advanced TDD topic under control! So, this is part 1. Remember to get part 2! OBAFGKMLT Welcome to Clean Code Episode 23 - Mocking; part of our sub-series on advanced Test Driven Development. In this episode we're going to learn about Test Doubles and Mocking. We begin with a little puppet show. You'll recognize the characters. You'll also recognize the situation; because, in all likelihood, you've been there - done that. That situation will lead us to a software architecture replete with dependency-inverted boundaries. As the players in our drama discuss how to test the features in that architecture, we'll gradually make the case for using mocks. Then we'll show you those mocks in a sequence of screencasts that begin with basic stubs and moving on to more involved spies. There's a lot of code to look at; and of course you can download it all from the extras link. Then we get all academic and study the classification of Test Doubles. We talk, in depth, about dummies, stubs, spies, mocks, and fakes. And there is plenty of code describing each. All that takes an hour. And at the end of that hour, part 1 comes to an end. But don't forget to watch part 2, because things get pretty interesting over there. In part 2 we're going to learn about the never ending struggle between Behavior and State; and the remarkable stress this dichotomy puts on our mocking strategies. This will lead us to: The Uncertainty Principle of TDD and the never ending battle between the Mockists and the Statists. Then we'll get all pragmatic and start examining some of the most useful mocking patterns such as: Self-Shunt, and Test-Specific Subclass, and my favorite: Humble Object. We'll show you, with lots of code, how and when these patterns should be applied. Indeed, we'll use the Humble Object pattern to show you how to test GUIs. We get a little Swing UI up and running and then show you how to separate the

The episode was rated #1 Best episode of Clean Code from 1 votes.

#12 - Mocking, Part 2
10.00
Season 4 - Episode 7

EGAD! Another two-part episode! I just can't seem to get this advanced TDD topic under control! So, this is part 1. Remember to get part 2! OBAFGKMLT Welcome to Clean Code Episode 23 - Mocking; part of our sub-series on advanced Test Driven Development. In this episode we're going to learn about Test Doubles and Mocking. We begin with a little puppet show. You'll recognize the characters. You'll also recognize the situation; because, in all likelihood, you've been there - done that. That situation will lead us to a software architecture replete with dependency-inverted boundaries. As the players in our drama discuss how to test the features in that architecture, we'll gradually make the case for using mocks. Then we'll show you those mocks in a sequence of screencasts that begin with basic stubs and moving on to more involved spies. There's a lot of code to look at; and of course you can download it all from the extras link. Then we get all academic and study the classification of Test Doubles. We talk, in depth, about dummies, stubs, spies, mocks, and fakes. And there is plenty of code describing each. All that takes an hour. And at the end of that hour, part 1 comes to an end. But don't forget to watch part 2, because things get pretty interesting over there. In part 2 we're going to learn about the never ending struggle between Behavior and State; and the remarkable stress this dichotomy puts on our mocking strategies. This will lead us to: The Uncertainty Principle of TDD and the never ending battle between the Mockists and the Statists. Then we'll get all pragmatic and start examining some of the most useful mocking patterns such as: Self-Shunt, and Test-Specific Subclass, and my favorite: Humble Object. We'll show you, with lots of code, how and when these patterns should be applied. Indeed, we'll use the Humble Object pattern to show you how to test GUIs. We get a little Swing UI up and running and then show you how to separate the

The episode was rated #2 Best episode of Clean Code from 1 votes.

#13 - Factories
10.00
Season 5 - Episode 2

So. Now it's time to talk about Factories. Factories. Lots and lots of Factory patterns. And no XML. In this episode we'll introduce three patterns in the family of factories. Factories! Lots .... And no XML. First, we'll talk about Abstract Factory. We'll show you why and when you'll want to use it, and what interesting little traps to watch out for. And that will start us on a lovely discussion about independent deployability, component design, jar files, type safety, type wars, smalltalk, Java, Eclipse, and No XML! Then we'll talk even more about the Factory Method and Prototype Patterns, and we'll discuss the problem of initialization. And we'll talk more about type safety, and language wars, and C vs. Pascal, and C++ vs. C, and Java vs. C++, and Smalltalk and Ruby, and NO NO NO XML!! Because we don't want to talk about XML. You heard me, right. NO XML! I don't want to hear about XML. I mean, for goodness sake, what were those guys thinking? XML was not a language that was designed for people to write! It was just a convenient syntax for a binary representation. You know, like X400, and X209, and ... What the bleeping bleep were those XSLT guys thinking. Or those ANT guys. And don't even get me started about Maven. Sheesh, angle brackets everywhere and I mean who the... It just makes me nuts that anybody would try to use XML for anything other than just looking at a data stream. I mean writing XML? WRITING XML???? That's just nuts, nuts, nuts. It's nuts I tell you. It's crazy kookie, wiered out nuts in the worm hole, and I don't know what to tell you these angle brackets are everywhere like little paperclips, like little spider legs, crawling, crawling up my spine and down my legs, and I just can't tolerate them all over me anymore and .....

The episode was rated #3 Best episode of Clean Code from 1 votes.

#14 - Finite State Machines and the State Pattern
10.00
Season 5 - Episode 4

Come all without. Come all within. You've not seen nothing like the mighty FSM. This episode is all about Finite State Machines. What they are. Why and when to use them. How to represent them. And how to implement them. Including implementing them with The State Pattern. Yes, this is part of our series on Design Patterns. It's also the first in at least three parts that will lead us from the State pattern to the Visitor pattern. It's going to be an interesting journey. We begin it here by talking about state machines and how remarkably useful they are, and how frustrating they can be to implement. By the end of this episode we'll have decided that the solution to that frustration is to write a compiler that generates the code from a simple syntax. The next few episodes will explore how to write that compiler; and how to use Finite State Machines to write that compiler. These next few episodes are going to be fun, challenging, and important. You aren't going to want to miss them.

The episode was rated #4 Best episode of Clean Code from 1 votes.

#15 - SMC Parser
10.00
Season 5 - Episode 5

OK boys and girls, things are really starting to heat up. In this episode we start writing a compiler! Remember,that's what we said we were going to do. We said we'd write a compiler that generates finite state machines. Well, that's what were doing. And, boy, is it a hoot. We begin by exploring the syntax of our state machine language. That syntax begins as a simple state transition table, and then we add a few cute bells and whistles, like super states, entry, and exit actions, that make writing state machines a bit more convenient. Next we formalize our syntax by expressing it in Backus-Naur Form (BNF). Then we write a lexical analyzer to identify the terminal tokens of our syntax. Then we write a parser that identifies the grammar of those terminal tokens. And, ironically, that parser is a finite state machine! Then we use the Builder Pattern to write a builder that constructs the internal representation of our syntax. And if you don't think that's enough for one episode, you're crazy. So, put your propeller caps on and take a big swig of brain juice, because we're about to plow headlong into the heady topic of Writing the State Machine Compiler!

The episode was rated #5 Best episode of Clean Code from 1 votes.

#16 - SMC Generator
10.00
Season 5 - Episode 6

Where is Uncle Bob? He invited us over for dinner and we've been waiting and waiting. Where could he be? It's unlike him to be this late? Wait! What's that sound? Great Heavens! Who is that wretched creature at the door, guzzling our wine like a man bereft of his senses. Prepare yourself for an interesting journey. A journey through the land of Code Generation and The Visitor Pattern. In this episode we conclude the mini-series on the State Machine Compiler. In the last episode we had just finished the parser. In this episode we'll see the Semantic Analyzer, the Optimizer, the Generator, the Abstract Syntax Tree, and the code generating Visitors. And that means we've got a lot of code to look at. While we are looking it over, we'll take a short diversion into the rationale, and variations of the Visitor Pattern. And we'll also do a quick review of the Composite Pattern. We'll also see how the discipline of Test Driven Development differs in certain larger projects, from the small Katas and examples that we've seen in the past. So clear your head, and free your mind. Red pill or blue? It's up to you.

The episode was rated #6 Best episode of Clean Code from 1 votes.

#17 - The Observer Pattern
10.00
Season 5 - Episode 7

OK, get ready for some fun. In this episode we're going to dive deep into the Observer pattern. The first thing we'll do is derive the pattern from first principles. We'll begin with a simple real-time clock application and, step by step, apply one design principle after another until the Observer pattern emerges. Well, actually, what emerges is a structure that our current most popular languages can't implement, because it requires multiple inheritance. So we'll explore the workarounds to that, and then we'll rant about why Java and C# don't have this useful feature. The Observer pattern comes in two forms. The "Push" model, and the "Pull" model. We'll describe them both and discuss when and where each is appropriate. Then we'll turn to the larger pattern that the Observer fits into: Model View Controller. We'll look at the history of MVC, and the unfortunate corruption of the pattern by current web frameworks. Finally, we'll invoke the Humble Object pattern for testing GUIs, and we'll derive the Model View Presenter pattern from MVC.

The episode was rated #7 Best episode of Clean Code from 1 votes.

#18 - Getting Clojure
10.00
Season 9 - Episode 10

This episode is the capstone of our Functional Programming series. In it we explore Clojure, the language that we've been using throughout the series. We'll start with a history of LISP. Where did it come from? Who invented it, and why? Then we'll talk about one of my favorite books. The Structure and Interpretation of Computer Programs. This is the book that first taught me LISP and Functional Programming. It's a classic, and it's one you should read. Then it's on to Clojure. This is not a tutorial. I'm not going to teach you all the ins and outs of the language. My goal is to give you just enough familiarity to make you curious. Clojure is Lisp. Clojure is Functional. Clojure rides on the JVM. Clojure supports concurrency. Next we'll spend a moment explaining how the data structures in Clojure can be simultaneously efficient and immutable. That's quite a trick, and you'll enjoy hearing about how it's done. Then we'll talk about lazy evaluation, and some of the costs and benefits of the technique. It's powerful, there's no doubt. But if you don't know what's going on behind the scenes, you can get into trouble that's hard to debug. Finally we'll discuss Macros and Homoiconicity (if that's a word.) Oh the power! THE POWER! This may be the most powerful aspect of LISP; and in Clojure it is especially powerful. It's so powerful, in fact, that you should hardly ever use it. And with that, we'll be done with the Functional Programming series.

The episode was rated #8 Best episode of Clean Code from 1 votes.

#19 - Strategy & Template Method Patterns
9.50
Season 5 - Episode 3

At long last, the episode you've been waiting for. The episode on Strategy and Protocol. No. Protocol and Template Method. No. Uh. Strategy and Template Method. Yeah, that's it. S&TM! In this episode we are going to tear into the unimaginably powerful, wildly complicated, and ultimately impenetrable Strategy pattern! Applause!!! In this episode the secrets will be revealed. The mysteries will be solved. The arcanities will be explained. The unknowable will be made known. You, yes you!, will at last understand how to employ the Strategy pattern, and it's brother the Template Method pattern. We'll talk about the costs, the benefits, the uses, and the abuses of these patterns. It'll be cool. It'll be really cool. It'll be revolutionarily coooool! So come on, what are you waiting for? It's time to dive, head first into the maw of the beast and uncover the ultimate truths of: **Strategy and Template Method**

The episode was rated #9 Best episode of Clean Code from 2 votes.

#20 - Clean Code
9.00
Season 1 - Episode 1

Get ready for something very different. This ain't no screen cast. This ain't no talkin' head lecture. This is an Uncle Bob Video! This is like watching Uncle Bob on stage, but more so. This is high content education that will hold your attention and stimulate your thoughts with its impactful and energetic style. So hold on to your hats and prepare yourself for a radically different kind of educational experience. In this video Uncle Bob shows why Clean Code is so important. He answers the question: Does Clean Code Matter? And he answers it emphatically in the affirmative! He explains how bad code leads to the downward spiral of The Productivity Trap. He describes the various ways and forms of Code Rot. And he concludes by answering the question: What is Clean Code? So don't wait. This one is almost a freebee. It's job is to convince you that you, your co-workers, and your managers will want (and need!) to see the rest. And besides, you don't really want to miss the astronomy lectures, do you?

The episode was rated #10 Best episode of Clean Code from 1 votes.

Last updated: oct 09, 2020

Search for TV shows...

About Me

I am Sophie and this is my website.

A little about me ๐Ÿ‘‹ I am a marketing student in Paris. I love spending afternoons with friends in a cafe or a park.

But more than anything else, I love watching (.. bingingโ€ฆ) series on my computer on rainy Sundays or any sunny day for that matter ๐Ÿ™ˆ

I must have watched hundreds of shows by now, from romance to science-fiction series. Often I like to go back to a show I enjoyed. But I donโ€™t feel like watching it all over againโ€ฆ

I created this website so myself and others could find the best episodes of our favourite shows. As of today, I have about 1,000 shows on the website with votes and rating coming from fans.

Hopefully, you can join me from your sofa and enjoy some nice TV!

- Sophie โ˜•๏ธ๐Ÿฐ