Tom Dalling - Latest Comments

Re: SOLID Class Design: The Liskov Substitution Principle

Bliii — Mon, 12 Aug 2024 03:34:53 -0000

Some ducks can fly

Re: Explaining Homogenous Coordinates & Projective Geometry

salah — Tue, 18 Jun 2024 06:19:16 -0000

This explanation is so good and so clear, thank you so much Tom.

Re: Modern OpenGL 04 – Cameras, Vectors & Input

Tom Dalling — Mon, 26 Jun 2023 07:45:50 -0000

Horizontal rotation (left/right) is around the Y axis, and vertical rotation (up/down) is around the X axis. You can visualise it as sticking a skewer through the object along the axis, then twisting the skewer. So if you want to spin the box left or right, you would have to skewer it along the Y axis.

Re: Modern OpenGL 04 – Cameras, Vectors & Input

ginko — Sun, 25 Jun 2023 10:54:04 -0000

Tom I have a question about the orientation. In the orientation method rotate the _verticalAngle with the X component and the _horizontalAngle withe the Y component. Shouldn't be the opposite? M'I missing something?

glm::mat4 Camera::orientation() const {
glm::mat4 orientation;
orientation = glm::rotate(orientation, glm::radians(_verticalAngle), glm::vec3(1,0,0));
orientation = glm::rotate(orientation, glm::radians(_horizontalAngle), glm::vec3(0,1,0));
return orientation;
}

Thanks for this tutorials

Re: Explaining Homogenous Coordinates & Projective Geometry

Tom Dalling — Sat, 19 Nov 2022 22:35:01 -0000

Thank you for the kind words!

Re: Explaining Homogenous Coordinates & Projective Geometry

Wenxin Liu — Wed, 16 Nov 2022 08:39:14 -0000

This explanation is so good and so clear, thank you so much Tom! You just explained something so clearly, that my professor couldn't explain in an hour.

Re: Coding Tip: Have A Single Exit Point

MikeSchinkel — Mon, 24 Oct 2022 16:27:21 -0000

Since it appears you are using C++ — vs Java or Javascript; did I intuit that correctly? — you can use a goto to really clean it up and get the best of both worlds.

Here is your example with goto and w/o the "yuck":

int MyArray::indexOfElement(int elementToFind){
  FooBar* fb = new FooBar;
  fb->openSomeFile();
  fb->startSomeWorkerThread();
  for(int i = 0; i < m_numberOfElements; ++i){
    if(this->elementAtIndex(i) != elementToFind){
      continue;
    }
    goto end;
  }
  i = ELEMENT_NOT_FOUND;
end:
  fb->closeSomeFile();
  fb->waitForWorkerThreadToFinish();
  delete fb;
  return i;
}

Re: FizzBuzz In Too Much Detail

gasmasq — Sun, 27 Feb 2022 18:56:23 -0000

Great Article

Re: Model View Controller Explained

kalam ahmed — Sun, 06 Feb 2022 22:16:33 -0000

explanations too good.

Re: FizzBuzz In Too Much Detail

ziplock9000 — Thu, 04 Feb 2021 11:57:16 -0000

Exactly.. "Meanwhile in the real world" really applies here.

Re: SOLID Class Design: The Open Closed Principle

Tom Dalling — Fri, 11 Sep 2020 02:59:28 -0000

Thank you! Kathy Sierra is a great teacher, so I am flattered.

Re: SOLID Class Design: The Open Closed Principle

Moksh M — Wed, 09 Sep 2020 01:15:07 -0000

I think you should be the co-author of Head First book series. You explain in very interesting way. I generally smile while reading your posts.

Re: FizzBuzz In Too Much Detail

Ultimate Dude — Mon, 17 Aug 2020 07:47:10 -0000

For Python just do
import fizzbuzz
fizzbuzz.generate(100)

ez lol /s

Re: FizzBuzz In Too Much Detail

shwetha kumar — Fri, 03 Apr 2020 23:56:42 -0000

get output like this in c language:
1 2 3 4 bus 6 7 8 9 Bus 11 12 13 14 bUs 16 17 18 19 bus 21 22 23 24 Bus 26 27 28 29 bUs....

Re: Explaining Homogenous Coordinates & Projective Geometry

Srishti Mukherjee — Fri, 15 Nov 2019 19:23:25 -0000

excellent post, thank you for sharing!

Re: Resource Acquisition is Initialisation (RAII) Explained

angelos.p — Sun, 27 Oct 2019 06:27:54 -0000

Great explanation. Thank you Tom!

Re: FizzBuzz In Too Much Detail

Sylvester Hesp — Tue, 22 Oct 2019 06:50:18 -0000

Not to spec, it never prints "FizzBuzz".

Re: FizzBuzz In Too Much Detail

David Shields — Tue, 15 Oct 2019 19:12:41 -0000

for(int x = 1; x < 101; x++) { Console.WriteLine((x % 3 == 0) ? "Fizz" : (x % 5 == 0) ? "Buzz" : x.ToString()); }

Re: SOLID Class Design: The Liskov Substitution Principle

K Serra — Thu, 10 Oct 2019 17:28:13 -0000

Great article, thought I'd add my take from a video game coder's perspective. I usually find the below solution easy to read and respects SRP. Often objects are expected to do silly things, but this also keeps things logical.

When an object belonging to a family requires a unique implementation of a behavior, this could possibly be a good opportunity to use the Strategy Design Pattern.

By using an abstract Base of "FlyType", one can then create concretions of: LowAltitude, HighAltitude, Ground, Underwater, and etc. This would offer more or less control over how the altitude effects the client.

I say 'more or less', because at this point you can set the altitude to zero, turn it negative(since penguins can dive underwater), or just rationalize that altitude for hopping penguins, since employing a null pattern here would still violate LSP I guess.

Implementation:
In the Bird base, make sure the concretions define their Fly/Altitude implementations:
public virtual void SetAltitude(double altitude) => Ground( ).Fly( altitude )
protected abstract FlyType( ) => new Ground( );

Re: Resource Acquisition is Initialisation (RAII) Explained

Tom Dalling — Mon, 09 Sep 2019 09:02:43 -0000

Let's say there are multiple std::shared_ptr objects that all contain the same pointer. When those objects get created/destroyed, it doesn't create/destroy the pointer, which is why I say that the pointer is not the "resource". Creating an object creates a lease (or a guarantee, or something like that), and destroying the object relinquishes the lease. So the resource being acquired/released is the lease, not the pointer.

Re: Resource Acquisition is Initialisation (RAII) Explained

Skrell — Tue, 03 Sep 2019 09:16:09 -0000

This article is awesome! But would you mind explaining the statement "std::shared_ptr is interesting, in that the "resource" is not the pointer itself — that's what std::unique_ptr does" a bit better? I'm not sure I follow your point... :(

Re: FizzBuzz In Too Much Detail

Tom Dalling — Tue, 27 Aug 2019 03:01:55 -0000

I could reply to you, or I could just direct you to read the rest of the article before commenting. Congrats on making a fool of yourself.

Re: FizzBuzz In Too Much Detail

Rick O'Shea — Mon, 26 Aug 2019 20:28:41 -0000

Congrats. You turned a concise function into unreadable garbage. You actually "got it" when you thought to ask why you would replace % with a function call, but you did it anyway with essentially zero justification other some vague reference to flexibility. Do you honestly NOT use binary operators (e.g., 2 + 2) because you want more flexibility in how to numbers are added? For sure you'd get an F had I been grading your result.

Re: SOLID Class Design: The Liskov Substitution Principle

Tom Dalling — Sun, 18 Aug 2019 02:52:34 -0000

Using birds that can't fly is an easy way to demonstrate the LSP, but it's not very representative of real-world code or good design, unfortunately. Probably the worst design sin committed here is mapping a "real world taxonomy" to a class hierarchy, which is a very common mistake. So yes, the abstraction isn't great, but it's also difficult to say what would be better, considering that it's a hypothetical application.

Re: SOLID Class Design: The Liskov Substitution Principle

Scott L. Bain — Mon, 12 Aug 2019 15:07:58 -0000

...but Penguins do have an altitude. Everything has an altitude. Penguins can also change their altitude, they do so by walking (like, up a hill) or diving into the water.