http://www.aiai.ed.ac.uk/~jeff/clos-guide.html

and

http://permalink.gmane.org/gmane.lisp.cl-pro/24

support the "make as implementation detail" view.

Some excerpts:

It's often a good idea to define your own constructor functions, rather
than call make-instance directly, because you can hide implementation
details and don't have to use keyword parameters for everything. For
instance, if you wanted the name and age to be required, positional
parameters, rather than keyword parameters, you could define

(defun make-person (name age)
  (make-instance 'person :name name :age age))

[Notice how more convolved implementing the same using initialize would be]
-------------

In addition to this, you'd use a factory function, rather than having
the client call make-instance, to hide the CLOS nature of the type.
 On Sep 3, 2014 1:47 PM, "Marko Rauhamaa" <marko@pacujo.net> wrote:

> Carlos Pita <carlosjosepita@gmail.com>:
>
> > So, a question to the experienced lispers here, a question that's not
> > specifically guile or goops or scheme related. Is the make (or
> > make-instance) way of constructing a new instance usually exposed to
> > the final user? Or a factory function, operating at a higher level of
> > abstraction, is intended to wrap the lower level, slot-fillig
> > oriented, call to make? In this case, a custom initialize method
> > implementation should be seen more as a complement to make than as a
> > proper constructor/factory.
>
> I saw the light and left goops behind. I built a simple system:
>
>  * Not slot-centric but method-centric.
>
>  * No classes, only objects.
>
> IMO, the end result is more schemey than Goops.
>
> It contains:
>
>     (make-object parentage . methods)
>
> where
>
>    parentage is #f, an object or a list of objects
>
>    methods contains procedures, or name-procedure pairs
>
> Example:
>
>    (define (<point> .x .y)
>      (define (x) .x)
>      (define (y) .y)
>      (make-object #f x y))
>
>    (let ((point (<point> 7 8)))
>      (point #:y))
>    => 8
>
> Marko
>