Uncle Bob illustrates how to use Jacobson's three primary architectural classes: Entities, Interactors, and Boundaries. Then he dives into a discussion on how to use names to Reveal Your Intent and Avoid Disinformation. I've also been a web developer for over a decade; but, I find that learning good and effective software development practices is proving to be a rather long journey. It aids your attention from drifting like when you have the same person in the same setting talking for an extended period of time. And, we still aren't using a framework.
There's just one problem: they didn't write any tests. So, Micah and I worked for a couple of hours getting our first acceptance tests close to passing. These changes have introduced architectural challenges to Web developers and make it more difficult to maintain best practices. What paradigms would it conform to? You'll be the third member of our pair. These topics just keep getting bigger and bigger. You'll like it, and you'll want to keep doing it. The data structures we'll use for this are going to quickly get very complicated.
We'll track the growth of our industry and its relationship to society at large. In part 2 things get really exciting, because in part 2 we explore the notion that these transformations have an ordering, a priority, that helps developers create better algorithms better code, and better design. Did you ever think that you would be combing through the innards of a real-time, interactive video game written in Clojure? I study learning and also have a keen interest in neuroscience and although it's not officially stated, I see a lot of it at play here. Did you know, for example, that the main program should be a plugin to the rest of the application? This is a reality show. Then Uncle Bob will introduce you to Barbara Liskov, and the principle of substitutability that she wrote about back in 1988. You must save the Federation. There's a lot of stuff going on in each one, so take your time and watch carefully.
You're going to love Monostate. Proxy is a pattern that is used when two objects need to communicate across a boundary, and should not know about that boundary. There are quite a few fun and interesting topics we're going to cover. We'll discuss the role we currently play in society, and the unwitting trust that society puts in us. Indeed, production code would never have exhibited the problem because production code would have been synchronized by sending messages between the sockets. We'll watch as society's view of programmers grew from shadowy figures behind the scenes to naive socially inept geeks to modern day heroes.
And we'll discover that the component structure of a system is a function of its maturity as well as of its behavior. But this time we're going to see it in the context of applying transformations using a certain priority. Memento is used when you want to capture the state of of an object inside an opaque token that can be passed around the system, and that can later be used to reconstitute the state of the captured object. Micah and Uncle Bob will review the videos and select their favorites to be shown as part of an upcoming episode. You'll weep and moan with the victims. I mean, for goodness sake, what were those guys thinking? Then, we use the Builder Pattern to write a builder that constructs the internal representation of our syntax. As Eisenhower said, the plan is eventually useless—the predicted results are not realized.
So, charge your phasers and raise your shields, because this episode is all about how to do Agile wrong. We'll use it to compare and contrast with the kinds of professional standards we might need here on Earth. See 3 For me as a professional developers it helps me to clean up my conscience to raise my personal standards by the inspiration I get from the videos. Distinguishing between tasteless and tasteful self-promotion is inherently subjective. What do they contain, then? 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. What data crosses the boundaries. You'll see what you need to see, without waiting for the typing.
In fact, we'll do it twice, with two different priorities. We learn that the command pattern is a way to decouple what is done from who does it. We'll talk about what it is, where it came from, how it relates to regular programming, and we'll even show you some code. You won't want to miss this part. Yes, this one is fun.
The tone is a bit more serious. Finally, we look at the actor model—a way to support hundreds or even thousands of threads in a memory constrained environment. We implemented a version of it back in Episode 9. Then we close by taking a lesson from Joel Spolsky when he criticized these principles several years back, without really knowing what they were. Because, after all, programming is the second most fun thing in the world! I highly recommend the videos.
We'll talk about our own ethics, our own standards, and the risk of continuing on our current path without establishing and enforcing those values. You will learn that the aim of agile development is to destroy hope and provide a cold dose of reality to managers and developers—because good management is impossible without facing reality. Next we talk about the problem that setup functions can grow to become unmanageable, and we address that problem by introducing the fascinating topic of hierarchical tests. The overriding rule that makes this architecture work is The Dependency Rule. Finally, we will look at Client-Server architecture and how its role in the Web has shifted over the last 50 years.
Don't worry, that's not the direction we're going. Abusive, racist, or derogatory comments are absolutely not tolerated. In this episode, we'll benefit again from this philosophy, except on the updating side, creating a simple coordinator object. We also struggle with the fact that we have not properly partitioned the use cases and presentations. We'll discuss when to pay down a debt and when to leave it well enough alone by combining our quality metrics along with information on churn and utilization. In order to avoid losing control of them, in a dynamically-typed language like Clojure, we're going to investigate the use of Clojure's type specification library clojure. As you hear them, you'll find that you'll hear them with two different ears: the ear of the customers and users will hear something perfectly reasonable, but the ear of the programmer will hear something insane and impossible.