Should "new" methods do anything?

[Philip Mak]

A programming style question:

Should "new" methods actually do anything, or should they only perform
initialization?

For example, let's say I have a class called "Httpd" which runs an
HTTP server. Should its interface be like this:

server = Httpd.new(:listen_port => 80) # Initialize the server
server.run # Run it

Or like this?

Httpd.new(:listen_port => 80) # Initialize and run the server

The latter way is more streamlined, but feels bad for some reason that
I can't quite put into words right now.

[Aredridel]

--=-xt6+981JgEI+5w0faYqy
Content-Type: text/plain
Content-Transfer-Encoding: quoted-printable

On Fri, 2003-09-12 at 14:03, Philip Mak wrote:

> A programming style question:
>=20
> Should "new" methods actually do anything, or should they only perform
> initialization?
>=20
> For example, let's say I have a class called "Httpd" which runs an
> HTTP server. Should its interface be like this:
>=20
> server =3D Httpd.new(:listen_port =3D> 80) # Initialize the server
> server.run # Run it
>=20
> Or like this?
>=20
> Httpd.new(:listen_port =3D> 80) # Initialize and run the server

Let it return self.

Then:

Httpd.new(:listen_port =3D> 80).run

>=20
> The latter way is more streamlined, but feels bad for some reason that
> I can't quite put into words right now.

Well, perhaps you want to wait to run until you've checked some
things...


--=-xt6+981JgEI+5w0faYqy
Content-Type: application/pgp-signature; name=signature.asc
Content-Description: This is a digitally signed message part

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.3 (GNU/Linux)

iD8DBQA/YicstP09exA3hooRAmRhAKDKuJR5RYYlaw0M1+MNcRestyuLSw CgoNzX
VsuKjF25CVlcnH0zm4ll288=
=Ie5W
-----END PGP SIGNATURE-----

--=-xt6+981JgEI+5w0faYqy--

[Weirich, James]

From: Philip Mak [mailto:pmak@aaanime.net]

> Should "new" methods actually do anything, or should they only perform
> initialization?

I prefer the initialize only approach. If you tried to subclass Httpd, then
running from initialize might start the server before the subclass has
completed initialization.

And if you want streamlined, Aredridel suggested chaining run.

--
-- Jim Weirich / Compuware
-- FWP Capture Services
-- Phone: 859-386-8855

[Sean O'Dell]

Philip Mak wrote:

> A programming style question:
>
> Should "new" methods actually do anything, or should they only perform
> initialization?
>
> For example, let's say I have a class called "Httpd" which runs an
> HTTP server. Should its interface be like this:
>
> server = Httpd.new(:listen_port => 80) # Initialize the server
> server.run # Run it
>
> Or like this?
>
> Httpd.new(:listen_port => 80) # Initialize and run the server
>
> The latter way is more streamlined, but feels bad for some reason that
> I can't quite put into words right now.

I don't think it will cause any harm to your program, but to me it's
non-intuitive as to what "new" does. I don't think many people would
expect that simply creating the server also launches it.

In those cases, I usually make a class method to combine the
functionality, i.e.:

server = Httpd::launch_server(:listen_port => 80)

.... and keep the class like this:

class Httpd
def initialize(listen_port)
# init only
end

def run
# launch the server
end

Httpd::launch_server(listen_port)
server = Https.new(:listen_port = listen_port)
server.run
return server
end
end


Sean O'Dell

[Simon Strandgaard]

On Fri, 12 Sep 2003 21:21:01 +0000, Sean O'Dell wrote:

> Philip Mak wrote:

>> A programming style question:
>>
>> Should "new" methods actually do anything, or should they only perform
>> initialization?

[snip]

>
> server = Httpd::launch_server(:listen_port => 80)

[snip]

>
> Httpd::launch_server(listen_port)
> server = Https.new(:listen_port = listen_port)
> server.run
> return server
> end

Yes, Factory methods is nice.. it can also look like this :-)

Httpd.launch(options=nil)
Https.new(options).run
end

--
Simon Strandgaard

[Austin Ziegler]

On Sat, 13 Sep 2003 05:03:51 +0900, Philip Mak wrote:

> For example, let's say I have a class called "Httpd" which runs an HTTP
> server. Should its interface be like this:
> server = Httpd.new(:listen_port => 80) # Initialize the server
> server.run # Run it
> Or like this?
> Httpd.new(:listen_port => 80) # Initialize and run the server
> The latter way is more streamlined, but feels bad for some reason that I
> can't quite put into words right now.

I would say:

server = Httpd.new(:listen_port => 80)
server.run

or

Httpd.new(:listen_port => 80) do |server|
...
end

If there's a block given, then both run it and stop it when the block
completes.

-austin
--
austin ziegler * [email]austin@halostatue.ca[/email] * Toronto, ON, Canada
software designer * pragmatic programmer * 2003.09.12
* 18.25.22

[Gavin Sinclair]

On Saturday, September 13, 2003, 6:03:51 AM, Philip wrote:

> A programming style question:

> Should "new" methods actually do anything, or should they only perform
> initialization?

> For example, let's say I have a class called "Httpd" which runs an
> HTTP server. Should its interface be like this:

> server = Httpd.new(:listen_port => 80) # Initialize the server
> server.run # Run it

> Or like this?

> Httpd.new(:listen_port => 80) # Initialize and run the server

> The latter way is more streamlined, but feels bad for some reason that
> I can't quite put into words right now.

The method is "doing too much", a common problem. You may want to
pass the server to another method which runs it, or not, based on some
other things.

Gavin