And feel free to use lerp, if you want, it does work. Just to give you an example (we will leave out delta for now so it's not confusing, but it's basically the same thing).
func _ready():
start_position = Vector(0, 0)
end_position = Vector2(100, 0)
percent = 0.0
func _process(delta):
position = start_position.linear_interpolate(end_position, percent)
percent += 0.2
In this case, the first frame the position.x is 0. Then 20, then 40, then 60, etc. until 100 (you'd also want to clamp it though, since you only want to pass in values from 0.0 to 1.0). This is linear (fixed movement).
You could also do something like this:
func _ready():
position = Vector(0, 0)
end_position = Vector2(100, 0)
func _process(delta):
position = position.linear_interpolate(end_position, 0.5)
The first frame x is 0, then it is 50, then it is 75, then it is 87, etc. So it moves fast at the beginning and gradually slows down to reach the end. This is usually a nice effect and in most cases what you want from camera movement, for example. I guess it's not exactly a hack (I mean, if it works it works). It's just you don't have a lot of control over it. So for simple non-gameplay effects, I would say it's still okay. Even for camera movement, this can be fine (though there are better ways, this is not bad). However, I would not use this method for anything about the core gameplay, character movement, attacking, AI, etc.
In general, using the physics engine as much as possible will keep things in sync better and keep the world stable. As it will work with collisions (even the camera may need collision, for example in a 3rd person game). It handles delta for you (at least with move_and_slide, which is mostly what you want to use) so it simplifies the code and reduces errors. It is frame rate independent, so the movement will look the same on an RTX 3090 or a piece of junk laptop. And you can still have easing and everything, though you will need to code it yourself as I showed above.
