Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.java.programmer > #15210 > unrolled thread

Single Class Object Model - new release

Back to article view | Back to comp.lang.java.programmer

Contents

  Single Class Object Model - new release micha <kernmichel@yahoo.fr> - 2012-06-11 15:45 -0700
    Re: Single Class Object Model - new release Lew <lewbloch@gmail.com> - 2012-06-11 16:38 -0700
      Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-11 18:39 -0700
        Re: Single Class Object Model - new release Leif Roar Moldskred <leifm@dimnakorr.com> - 2012-06-11 20:55 -0500
          Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-11 21:42 -0700
            Re: Single Class Object Model - new release Robert Klemme <shortcutter@googlemail.com> - 2012-06-12 18:24 +0200
              Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-12 13:09 -0700
                Re: Single Class Object Model - new release Robert Klemme <shortcutter@googlemail.com> - 2012-06-12 23:48 +0200
                  Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-13 01:12 -0700
                    Re: Single Class Object Model - new release Robert Klemme <shortcutter@googlemail.com> - 2012-06-13 06:44 -0700
                      Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-13 15:22 -0700
                        Re: Single Class Object Model - new release Robert Klemme <shortcutter@googlemail.com> - 2012-06-14 00:56 -0700
                          Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-14 03:24 -0700
                        Re: Single Class Object Model - new release Leif Roar Moldskred <leifm@dimnakorr.com> - 2012-06-14 12:27 -0500
            Re: Single Class Object Model - new release Lew <lewbloch@gmail.com> - 2012-06-12 10:05 -0700
              Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-12 13:03 -0700
                Re: Single Class Object Model - new release Leif Roar Moldskred <leifm@dimnakorr.com> - 2012-06-12 15:58 -0500
                  Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-13 02:08 -0700
                Re: Single Class Object Model - new release Robert Klemme <shortcutter@googlemail.com> - 2012-06-12 23:33 +0200
                Re: Single Class Object Model - new release markspace <-@.> - 2012-06-12 15:15 -0700
                  Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-13 02:57 -0700
                    Re: Single Class Object Model - new release markspace <-@.> - 2012-06-13 08:26 -0700
                      Re: Single Class Object Model - new release micha <ludicite@gmail.com> - 2012-06-13 15:17 -0700
                        Re: Single Class Object Model - new release Lew <noone@lewscanon.com> - 2012-06-13 19:06 -0700
                          Re: Single Class Object Model - new release markspace <-@.> - 2012-06-13 19:15 -0700

Page 1 of 2  [1] 2  Next page →

#15210 — Single Class Object Model - new release

--------------------------------------------------------------
              SCOM: Single Class Object Model
              ------------------------------
              ----- Programmer's Guide -----
              ------------------------------
        www.terimakasi.com    28 may 2012 - 22:52
            https://github.com/terimakasi/scom
--------------------------------------------------------------
1. Introduction
---------------
  SCOM is a exercise in style with a 'constructivist' motivation. The
purpose is to design an Model Objet provided
  as a Single class (!!), called 'It' (core/root class).

  SCOM paradigm is founded on top of 3 'Design Intents':

  a. Runtime Semantic Network
  ---------------------------
     SCOM provides an easy and straightforward way to creatr 'semantic
networks' at runtime (much like XML DOM)
     The atoms of SCOM semantic networks are RDF-like triples (Subject
--Predicate--> Object).
     In SCOM, all 3 parts of the triple are 'It' instances
     - 'Subject':   is an It instance
     - 'Predicate': is an unidirectional relation, it is called a
'facet'
     - 'Object':    is called a 'facet value'

  b. Self evaluation instances
  ----------------------------
     Inspired by functional programming (especially 'Lisp'). Thus
Application behavior is implemented:
     - by overriding 'evaluate' method in subclasses of 'It'
     - once a subclass implements a method, it could then be added to
an It instance as a 'behavioral facet'

  c. Native Adaptative Object Model
  ---------------------------------
     SCOM supports the AOM paradigm (Adaptative Object Model), where
business domain classes are not static like
     'regular OOP languages' (e.g: Java, C#/C++) but instead
dynamically created at runtime (much like
     classes described by Semantic Web Ontology language: 'Owl')

[toc] | [next] | [standalone]

#15212

micha wrote:
> --------------------------------------------------------------
>               SCOM: Single Class Object Model
>               ------------------------------
>               ----- Programmer's Guide -----
>               ------------------------------
[snip]
> --------------------------------------------------------------
> 1. Introduction
> ---------------
>   SCOM is a exercise in style with a 'constructivist' motivation. The
> purpose is to design an Model Objet provided

I believe "objet" is the French word, is it not?

>   as a Single class (!!), called 'It' (core/root class).

What do the exclamation points signify?

>   SCOM paradigm is founded on top of 3 'Design Intents':
> 
>   a. Runtime Semantic Network

Meaning what, exactly?

>   ---------------------------
>      SCOM provides an easy and straightforward way to creatr 'semantic
> networks' at runtime (much like XML DOM)
>      The atoms of SCOM semantic networks are RDF-like triples (Subject
> --Predicate--> Object).
>      In SCOM, all 3 parts of the triple are 'It' instances
>      - 'Subject':   is an It instance
>      - 'Predicate': is an unidirectional relation, it is called a
> 'facet'
>      - 'Object':    is called a 'facet value'
> 
>   b. Self evaluation instances
>   ----------------------------
>      Inspired by functional programming (especially 'Lisp'). Thus
> Application behavior is implemented:
>      - by overriding 'evaluate' method in subclasses of 'It'
>      - once a subclass implements a method, it could then be added to
> an It instance as a 'behavioral facet'
> 
>   c. Native Adaptative Object Model
>   ---------------------------------
>      SCOM supports the AOM paradigm (Adaptative Object Model), where
> business domain classes are not static like
>      'regular OOP languages' (e.g: Java, C#/C++) but instead
> dynamically created at runtime (much like
>      classes described by Semantic Web Ontology language: 'Owl')

How does this pertain to Java programming?

How will it help Java programmers?

-- 
Lew

[toc] | [prev] | [next] | [standalone]

#15218

On 12 juin, 01:38, Lew <lewbl...@gmail.com> wrote:
> micha wrote:
> > --------------------------------------------------------------
> >               SCOM: Single Class Object Model
> >               ------------------------------
> >               ----- Programmer's Guide -----
> >               ------------------------------
> [snip]
> > --------------------------------------------------------------
> > 1. Introduction
> > ---------------
> >   SCOM is a exercise in style with a 'constructivist' motivation. The
> > purpose is to design an Model Objet provided
>
> I believe "objet" is the French word, is it not?
>
> >   as a Single class (!!), called 'It' (core/root class).
>
> What do the exclamation points signify?
>
> >   SCOM paradigm is founded on top of 3 'Design Intents':
>
> >   a. Runtime Semantic Network
>
> Meaning what, exactly?
>
>
>
>
>
>
>
>
>
> >   ---------------------------
> >      SCOM provides an easy and straightforward way to creatr 'semantic
> > networks' at runtime (much like XML DOM)
> >      The atoms of SCOM semantic networks are RDF-like triples (Subject
> > --Predicate--> Object).
> >      In SCOM, all 3 parts of the triple are 'It' instances
> >      - 'Subject':   is an It instance
> >      - 'Predicate': is an unidirectional relation, it is called a
> > 'facet'
> >      - 'Object':    is called a 'facet value'
>
> >   b. Self evaluation instances
> >   ----------------------------
> >      Inspired by functional programming (especially 'Lisp'). Thus
> > Application behavior is implemented:
> >      - by overriding 'evaluate' method in subclasses of 'It'
> >      - once a subclass implements a method, it could then be added to
> > an It instance as a 'behavioral facet'
>
> >   c. Native Adaptative Object Model
> >   ---------------------------------
> >      SCOM supports the AOM paradigm (Adaptative Object Model), where
> > business domain classes are not static like
> >      'regular OOP languages' (e.g: Java, C#/C++) but instead
> > dynamically created at runtime (much like
> >      classes described by Semantic Web Ontology language: 'Owl')
>
> How does this pertain to Java programming?
>
> How will it help Java programmers?
>
> --
> Lew

Thanks for your answer Lew

- Yes there's a typo 'Objet' instead of 'Object', not a big deal

- Regarding the !! and 'semantic network' question, here's my answer:
!! is because an Object Model with a single class may seem foolish/
dummy/useless/stoopid but in fact it's may also be considered:
- as a creative  challenge
- moreover as a way to show that it(s not mandatory that the
usefulness of an object model resideds in it's API (the default
assumption), but instead in the semantic network of instances that you
can build with it, that's the main idea within SCOM: it's instances
are easily assembled in a semantic network by using triples as the
semantic atom (Subject --predicayte--> Object, like RDF which is the
foundation of Semantic Web)

- The relation with Java is to highlight that Java has a buildtime/
static object model (instances are dynamic/runtime but classes are
static/buildtime) and that there is another paradigm called AOM
(Adaptative Object Model) where classes are dynamic too. SCOM is an
illustration that this paradigm can be implemented on top of Java thus
opening new possibilities which are not reachable with a static object
model

[toc] | [prev] | [next] | [standalone]

#15219

micha <ludicite@gmail.com> wrote:

> - moreover as a way to show that it(s not mandatory that the
> usefulness of an object model resideds in it's API (the default
> assumption), but instead in the semantic network of instances that you
> can build with it, that's the main idea within SCOM: it's instances
> are easily assembled in a semantic network by using triples as the
> semantic atom (Subject --predicayte--> Object, like RDF which is the
> foundation of Semantic Web)

Wouldn't it be easier and more convenient to just program in Common
Lisp from the get go? (The above just strikes me as an example of
Greenspun's tenth rule in action.)

-- 
Leif Roar Moldskred

[toc] | [prev] | [next] | [standalone]

#15223

On 12 juin, 03:55, Leif Roar Moldskred <le...@dimnakorr.com> wrote:
> micha <ludic...@gmail.com> wrote:
> > - moreover as a way to show that it(s not mandatory that the
> > usefulness of an object model resideds in it's API (the default
> > assumption), but instead in the semantic network of instances that you
> > can build with it, that's the main idea within SCOM: it's instances
> > are easily assembled in a semantic network by using triples as the
> > semantic atom (Subject --predicayte--> Object, like RDF which is the
> > foundation of Semantic Web)
>
> Wouldn't it be easier and more convenient to just program in Common
> Lisp from the get go? (The above just strikes me as an example of
> Greenspun's tenth rule in action.)
>
> --
> Leif Roar Moldskred

Hello Leif

Thanks for the Greenspun's tenth rule (thought I matbe heard about it
long time ago but that's a nice piece of thinking to highlight for
sure)
Well, Lisp especially Common Lisp is pure in the intention not so much
in the facts: there's a huge number of functions in Common Lisp, not
all
absolutely legitimate to be in the core of a language, then there was
Scheme which seems to be a 'minimalist Scheme'. In fact all functional
languages share this property to leverage the expressiveness, now we
have functional (lambda calculus) in a wide variety of flavors even
some on JVM (Scala, Groovy, Clojure) or CLR (Clojure, F#)

BUT nevertheless Java has an unsurpassed firepower with tons of
libraries, frameworks and dialects, so it could be useful if only for
that reason (while  Lisp developers have much more trouble to find
software components for their needs so they may find themselves
working hard to wrap a java component for Lisp instead of writing the
business domain code)

AND SCOM is not only about levererage of functional programming but
also:
- about Adaptative Object Model (which is also already native but more
in Smalltalk than in Lisp as Common Lisp is not an Object language
from the start but requires an extension layer (CLOS) to support
Object paradigm)
- and about Semantic Web paradigm, starting with semantic networks
described as triples by RDF/Owl:SCOM provides a simple and
  straightforward mechanism (addfacet() method)  to build such 'triple
based' semantic networks at runtime (like DOM is the runtime
  data structure counterpart of an XML file)

NOW there is Scala which is both functional and Object BUT not a
purely interpreted metalanguage like Lisp (Lisp allows to define new
Languages with it's bootstrapping/dynamic syntax capabilities)

SO SCOM is not an attempt to do better than breakthrough languages
like Scala, it's only an attempt to show that within Java microcosm,
there's still ways to leverage expressiveness by adopting new
paradigms namely Adaptative Object Model, Semantic Web inspired
runtime data structures (not by extending Java with tons of new
features which address implementation needs without really adding
expressiveness or in the best case clearing out some inconsistencies,
like int vs Integer, [] vs ArrayList etc...)

[toc] | [prev] | [next] | [standalone]

#15225

On 12.06.2012 06:42, micha wrote:

> BUT nevertheless Java has an unsurpassed firepower with tons of
> libraries, frameworks and dialects,

But you don't want to use them because you just want to have a single 
class, do you?

> AND SCOM is not only about levererage of functional programming but
> also:
> - about Adaptative Object Model (which is also already native but more
> in Smalltalk than in Lisp as Common Lisp is not an Object language
> from the start but requires an extension layer (CLOS) to support
> Object paradigm)
> - and about Semantic Web paradigm, starting with semantic networks
> described as triples by RDF/Owl:SCOM provides a simple and
>    straightforward mechanism (addfacet() method)  to build such 'triple
> based' semantic networks at runtime (like DOM is the runtime
>    data structure counterpart of an XML file)
>
> NOW there is Scala which is both functional and Object BUT not a
> purely interpreted metalanguage like Lisp (Lisp allows to define new
> Languages with it's bootstrapping/dynamic syntax capabilities)
>
> SO SCOM is not an attempt to do better than breakthrough languages
> like Scala, it's only an attempt to show that within Java microcosm,
> there's still ways to leverage expressiveness by adopting new
> paradigms namely Adaptative Object Model, Semantic Web inspired
> runtime data structures (not by extending Java with tons of new
> features which address implementation needs without really adding
> expressiveness or in the best case clearing out some inconsistencies,
> like int vs Integer, [] vs ArrayList etc...)

I still did not get what the purpose of this exercise is.  Why do you do 
this?  To what end?

Cheers

	robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

[toc] | [prev] | [next] | [standalone]

#15227

On 12 juin, 18:24, Robert Klemme <shortcut...@googlemail.com> wrote:
> On 12.06.2012 06:42, micha wrote:
>
> > BUT nevertheless Java has an unsurpassed firepower with tons of
> > libraries, frameworks and dialects,
>
> But you don't want to use them because you just want to have a single
> class, do you?
>
>
>
>
>
>
>
>
>
> > AND SCOM is not only about levererage of functional programming but
> > also:
> > - about Adaptative Object Model (which is also already native but more
> > in Smalltalk than in Lisp as Common Lisp is not an Object language
> > from the start but requires an extension layer (CLOS) to support
> > Object paradigm)
> > - and about Semantic Web paradigm, starting with semantic networks
> > described as triples by RDF/Owl:SCOM provides a simple and
> >    straightforward mechanism (addfacet() method)  to build such 'triple
> > based' semantic networks at runtime (like DOM is the runtime
> >    data structure counterpart of an XML file)
>
> > NOW there is Scala which is both functional and Object BUT not a
> > purely interpreted metalanguage like Lisp (Lisp allows to define new
> > Languages with it's bootstrapping/dynamic syntax capabilities)
>
> > SO SCOM is not an attempt to do better than breakthrough languages
> > like Scala, it's only an attempt to show that within Java microcosm,
> > there's still ways to leverage expressiveness by adopting new
> > paradigms namely Adaptative Object Model, Semantic Web inspired
> > runtime data structures (not by extending Java with tons of new
> > features which address implementation needs without really adding
> > expressiveness or in the best case clearing out some inconsistencies,
> > like int vs Integer, [] vs ArrayList etc...)
>
> I still did not get what the purpose of this exercise is.  Why do you do
> this?  To what end?
>
> Cheers
>
>         robert
>
> --
> remember.guy do |as, often| as.you_can - without endhttp://blog.rubybestpractices.com/

- It(s not that I don't want to use them, in fact I use the Javascript
interpreter in SCOM.
- The purpose is to show to Java programmer's that:
  1. there are alternate Object Model paradigms, especially Adaptative
Object Model (where classes are defined and extensible at runtime)
  2. That the API may be outside of the class and instead in the
semantic network of agnostic instances (which is the purpose of It
class in SCOM)
      SCOM allows easy creation of a semantic networl of its own
instances at runtime, and it is this network which becomes the API,
the It class
      API is just an enabler (like machine code vs programming
language)

[toc] | [prev] | [next] | [standalone]

#15231

Please truncate quotes properly.

On 12.06.2012 22:09, micha wrote:
> - The purpose is to show to Java programmer's that:
>    1. there are alternate Object Model paradigms, especially Adaptative
> Object Model (where classes are defined and extensible at runtime)

OK, no surprise here.

>    2. That the API may be outside of the class and instead in the
> semantic network of agnostic instances (which is the purpose of It
> class in SCOM)
>        SCOM allows easy creation of a semantic networl of its own
> instances at runtime, and it is this network which becomes the API,
> the It class
>        API is just an enabler (like machine code vs programming
> language)

I look at
https://github.com/terimakasi/scom/blob/717f9b9e6748656b5bfcf439147e04b6293b8544/samples/arithmetic/Test_Add.java

Here you created a graph of objects which contain functionality in a 
similar way a interpreter could use internally.  Instead of invoking a 
method "add" on an instance of a numeric class you have a generic method 
"evaluate" - and that obviously behaves different for something that was 
created in a special way (with arguments ItAddF.BASENAME, 
ItAddF.BASENAME, ItAddF.CLASS_NAME).  Basically you replaced specific 
methods with specific instances which behave differently.  No surprises 
here as well - that's a common idiom if you want to stick together 
algorithms at runtime.

Now that you've shown it, why should I care?  Put differently: what can 
I do better with this than with - say - plain Java?  Apparently you are 
trying to sell something but I fail to see the benefit or why you post 
it in a Java newsgroup.

Cheers

	robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

[toc] | [prev] | [next] | [standalone]

#15237

On 12 juin, 23:48, Robert Klemme <shortcut...@googlemail.com> wrote:
> Please truncate quotes properly.
>
> On 12.06.2012 22:09, micha wrote:
>
> > - The purpose is to show to Java programmer's that:
> >    1. there are alternate Object Model paradigms, especially Adaptative
> > Object Model (where classes are defined and extensible at runtime)
>
> OK, no surprise here.
>
> >    2. That the API may be outside of the class and instead in the
> > semantic network of agnostic instances (which is the purpose of It
> > class in SCOM)
> >        SCOM allows easy creation of a semantic networl of its own
> > instances at runtime, and it is this network which becomes the API,
> > the It class
> >        API is just an enabler (like machine code vs programming
> > language)
>
> I look athttps://github.com/terimakasi/scom/blob/717f9b9e6748656b5bfcf439147e0...
>
> Here you created a graph of objects which contain functionality in a
> similar way a interpreter could use internally.  Instead of invoking a
> method "add" on an instance of a numeric class you have a generic method
> "evaluate" - and that obviously behaves different for something that was
> created in a special way (with arguments ItAddF.BASENAME,
> ItAddF.BASENAME, ItAddF.CLASS_NAME).  Basically you replaced specific
> methods with specific instances which behave differently.  No surprises
> here as well - that's a common idiom if you want to stick together
> algorithms at runtime.
>
> Now that you've shown it, why should I care?  Put differently: what can
> I do better with this than with - say - plain Java?  Apparently you are
> trying to sell something but I fail to see the benefit or why you post
> it in a Java newsgroup.
>
> Cheers
>
>         robert
>
> --
> remember.guy do |as, often| as.you_can - without endhttp://blog.rubybestpractices.com/

Hello Robert

Thanks for your sharp feedback, you are right the idioms are not new.

In fact what I would like to 'sell' like you say is that 'static
object modelling' is in my view
obsolete because a model (the 'science componenr') is our
understanding of a system
at the time being and it will sooner or later need to be refactored
with all the impacts
to manage (user interface, user's guide, prog's guide, test
suite, ...)

Thus I'm convinced that we need for the future both a new mindset and
a new toolset
which would allow to apprehend the model as a system in a continuum
space
of improvements while from what I've observed until now there is much
more often
the continuous cluttering of a system until it's considered
unmanageable and
then after lots of hesitation ('cost control'), it's garbaged and
rebuild from scratch

My little 'toy project' / exercise is not a solution more an attempt
to motivate
another point of view on common 'oop' paradigms and also a tool
to experiment because of it's constructivist approach (single class).

'Single Class Object Model' seems dummy/stupid/useless but I in fact
found it as
a good creativity exercise with a good 'unfold' potential that's why I
wanted to
 share with the community (at least for a feedback, and that's why I'm
getting
so I thank all the people sending me a feedback)

[toc] | [prev] | [next] | [standalone]

#15241

On Wednesday, June 13, 2012 10:12:03 AM UTC+2, micha wrote:
> On 12 juin, 23:48, Robert Klemme <shortcut...@googlemail.com> wrote:
> > Please truncate quotes properly.

Is there a reason why you ignored that request.

> In fact what I would like to 'sell' like you say is that 'static
> object modelling' is in my view
> obsolete because a model (the 'science componenr') is our
> understanding of a system
> at the time being and it will sooner or later need to be refactored
> with all the impacts
> to manage (user interface, user's guide, prog's guide, test
> suite, ...)
> 
> Thus I'm convinced that we need for the future both a new mindset and
> a new toolset
> which would allow to apprehend the model as a system in a continuum
> space
> of improvements while from what I've observed until now there is much
> more often
> the continuous cluttering of a system until it's considered
> unmanageable and
> then after lots of hesitation ('cost control'), it's garbaged and
> rebuild from scratch

It seems to me you haven't done a lot software engineering yet.  Problem is: you just shift the syntactic level from plain java methods to construction of object graphs.  But that does not reduce the complexity of a system.  Both approaches can be made in a good (manageable) and bad (unmanageable) way.  You won't stop customers (or reality) from adding requirements to an existing piece of software.  Hence with any approach you need to change software which usually comes with an increased complexity.  You also need to test an application - black box tests are not affected by your approach at all since all the public APIs remain intact.

> My little 'toy project' / exercise is not a solution more an attempt
> to motivate
> another point of view on common 'oop' paradigms and also a tool
> to experiment because of it's constructivist approach (single class).
> 
> 'Single Class Object Model' seems dummy/stupid/useless but I in fact
> found it as
> a good creativity exercise with a good 'unfold' potential that's why I
> wanted to
>  share with the community (at least for a feedback, and that's why I'm
> getting
> so I thank all the people sending me a feedback)

Things would have gone better with the feedback if you had included this information in the first posting instead.

Cheers

robert

[toc] | [prev] | [next] | [standalone]

#15257

On 13 juin, 15:44, Robert Klemme <shortcut...@googlemail.com> wrote:
> On Wednesday, June 13, 2012 10:12:03 AM UTC+2, micha wrote:
> > On 12 juin, 23:48, Robert Klemme <shortcut...@googlemail.com> wrote:
> > > Please truncate quotes properly.
>
> Is there a reason why you ignored that request.
>
>
>
>
>
>
>
>
>
> > In fact what I would like to 'sell' like you say is that 'static
> > object modelling' is in my view
> > obsolete because a model (the 'science componenr') is our
> > understanding of a system
> > at the time being and it will sooner or later need to be refactored
> > with all the impacts
> > to manage (user interface, user's guide, prog's guide, test
> > suite, ...)
>
> > Thus I'm convinced that we need for the future both a new mindset and
> > a new toolset
> > which would allow to apprehend the model as a system in a continuum
> > space
> > of improvements while from what I've observed until now there is much
> > more often
> > the continuous cluttering of a system until it's considered
> > unmanageable and
> > then after lots of hesitation ('cost control'), it's garbaged and
> > rebuild from scratch
>
> It seems to me you haven't done a lot software engineering yet.  Problem is: you just shift the syntactic level from plain java methods to construction of object graphs.  But that does not reduce the complexity of a system.  Both approaches can be made in a good (manageable) and bad (unmanageable) way.  You won't stop customers (or reality) from adding requirements to an existing piece of software.  Hence with any approach you need to change software which usually comes with an increased complexity.  You also need to test an application - black box tests are not affected by your approach at all since all the public APIs remain intact.
>
> > My little 'toy project' / exercise is not a solution more an attempt
> > to motivate
> > another point of view on common 'oop' paradigms and also a tool
> > to experiment because of it's constructivist approach (single class).
>
> > 'Single Class Object Model' seems dummy/stupid/useless but I in fact
> > found it as
> > a good creativity exercise with a good 'unfold' potential that's why I
> > wanted to
> >  share with the community (at least for a feedback, and that's why I'm
> > getting
> > so I thank all the people sending me a feedback)
>
> Things would have gone better with the feedback if you had included this information in the first posting instead.
>
> Cheers
>
> robert

> It seems to me you haven't done a lot software engineering yet.
> Problem is: you just shift the syntactic level from plain java methods to construction of object graphs
It seems you haven't noticed what's happening with SemanticWeb (RDF/
Owl and triplestores) and how the paradigms it brought could change
the programming landscape
Please don't change your mind, you know better than me for sure...

[toc] | [prev] | [next] | [standalone]

#15269

Dang, you did it again: you really need to improve your newsgroup quoting skills.  See http://en.wikipedia.org/wiki/Netiquette

On Thursday, June 14, 2012 12:22:30 AM UTC+2, micha wrote:
> > It seems to me you haven't done a lot software engineering yet.
> > Problem is: you just shift the syntactic level from plain java methods to construction of object graphs
> It seems you haven't noticed what's happening with SemanticWeb (RDF/
> Owl and triplestores) and how the paradigms it brought could change
> the programming landscape

I even worked in projects that dealt with aspects of semantic web.  Last time I checked it was as live as object databases.  Considering the age of the idea wouldn't you believe that it had changed software development _already_ if the benefits are so dramatic?

Basically it's the same niche as AI.  To my knowledge there is no common agreement yet what it means to say "a computer (or program) understands something".  Basically it is us humans who decide whether we think someone understands something and we do this based on interactions (see turing test).  But what aspects belong to this interaction (i.e. only textual via a screen and keyboard, hand shaking, face mimic etc.) is not clear at all.

Over and out

robert

[toc] | [prev] | [next] | [standalone]

#15273

On 14 juin, 09:56, Robert Klemme <shortcut...@googlemail.com> wrote:
> Dang, you did it again: you really need to improve your newsgroup quoting skills.  Seehttp://en.wikipedia.org/wiki/Netiquette
>
> On Thursday, June 14, 2012 12:22:30 AM UTC+2, micha wrote:
> > > It seems to me you haven't done a lot software engineering yet.
> > > Problem is: you just shift the syntactic level from plain java methods to construction of object graphs
> > It seems you haven't noticed what's happening with SemanticWeb (RDF/
> > Owl and triplestores) and how the paradigms it brought could change
> > the programming landscape
>
> I even worked in projects that dealt with aspects of semantic web.  Last time I checked it was as live as object databases.  Considering the age of the idea wouldn't you believe that it had changed software development _already_ if the benefits are so dramatic?
>
> Basically it's the same niche as AI.  To my knowledge there is no common agreement yet what it means to say "a computer (or program) understands something".  Basically it is us humans who decide whether we think someone understands something and we do this based on interactions (see turing test).  But what aspects belong to this interaction (i.e. only textual via a screen and keyboard, hand shaking, face mimic etc.) is not clear at all.
>
> Over and out
>
> robert

Hello Robert, Markspace

Thanks again for your feedback, comments, critics (even if critics are
harder to hear than encouragements, you took the time to analyse and
write down an answer and that's better than indifference)

I confess that the project/idea has started only 1 month ago and I was
surely too much excited to present it at a too early stage ('Fast and
Loose', I'm very childish in fact even at 49 years)

I also mixed in old grudges (in my past experience at Dassault
Systemes1991-2000) which were more confusing than helping or providing
any real argument.

I still think I have found something interesting to dig (considering
it as an exercise/playground not a solution) and may come back when
there is more stuff to illustrate what has unfold from it. I think
that the idea could lead to 'object graph editor/debugger' as I
explained previously, but that's a much tougher work (and moreover
maybe it has already been explored by research in the IDE area)

Maybe this newsgroup is not the right place to present this kind of
ideas, as it's more theoric than pragmatic, and I guess that I maybe
just stumbled on a concept (or part of a concept) which may have
already been explored by researchers and at a much deeper level
I'm thinking about bootstrapping feature at the time being, Robert do
you have any advice / tracks for learning about this ? I feel
bootstrapping is an amazing (and mysterious) concept (at the core of
languages like Smalltalk/Lisp/Squeak and SW solutions like Eclipse/
OSGI), if I have already experimented self-extensibility wih Java
reflection and dynamic loading of jars but I think I don't have the
clues yet to implement in in an elegant way

[toc] | [prev] | [next] | [standalone]

#15282

micha <ludicite@gmail.com> wrote:
> It seems you haven't noticed what's happening with SemanticWeb (RDF/
> Owl and triplestores) and how the paradigms it brought could change
> the programming landscape

Oh, another one?

"I've seen 'em come and go and I've seen 'em die
And long ago I stopped askin' why" 
                                       - Johnny Cash, San Quentin

"And it should be the law: If you use the word 'paradigm' without
knowing what the dictionary says it means, you go to jail. No
exceptions."
                                                    - David Jones

-- 
Leif Roar Moldskred

[toc] | [prev] | [next] | [standalone]

#15226

micha wrote:
> SO SCOM is not an attempt to do better than breakthrough languages
> like Scala, it's only an attempt to show that within Java microcosm,
> there's still ways to leverage expressiveness by adopting new
> paradigms namely Adaptative Object Model, Semantic Web inspired
> runtime data structures (not by extending Java with tons of new
> features which address implementation needs without really adding
> expressiveness or in the best case clearing out some inconsistencies,
> like int vs Integer, [] vs ArrayList etc...)

There is nothing inconsistent between 'int' and 'Integer', nor between 
arrays and 'ArrayList' in Java.

Likewise there is nothing inconsistent between 'enum's and 'java.io.Reader' 
implementations.

-- 
Lew

[toc] | [prev] | [next] | [standalone]

#15228

On 12 juin, 19:05, Lew <lewbl...@gmail.com> wrote:
> micha wrote:
> > SO SCOM is not an attempt to do better than breakthrough languages
> > like Scala, it's only an attempt to show that within Java microcosm,
> > there's still ways to leverage expressiveness by adopting new
> > paradigms namely Adaptative Object Model, Semantic Web inspired
> > runtime data structures (not by extending Java with tons of new
> > features which address implementation needs without really adding
> > expressiveness or in the best case clearing out some inconsistencies,
> > like int vs Integer, [] vs ArrayList etc...)
>
> There is nothing inconsistent between 'int' and 'Integer', nor between
> arrays and 'ArrayList' in Java.
>
> Likewise there is nothing inconsistent between 'enum's and 'java.io.Reader'
> implementations.
>
> --
> Lew

Yes it's inconsistent:
- because [] and ArrayList/Collections are 2 different ways to handle
vectors/lists (while there is only 1 in Python/Lisp/Perl
- because int is a primitive type (like in procedural languages)
while Integer are Objects (the bypass to put integers in a Collection
in fact)
  instead all entities in Scala/Smalltalk are Objects (even
functions), and scripting language (Python/Perl/PHP/Lisp) provide lazy
typing and are thus
  more consistent (even if at the price of more risk to write
erroneous code which language laziness will let go through)

[toc] | [prev] | [next] | [standalone]

#15229

micha <ludicite@gmail.com> wrote:
> 
> Yes it's inconsistent:
> - because [] and ArrayList/Collections are 2 different ways to handle
> vectors/lists (while there is only 1 in Python/Lisp/Perl

To be rather blunt about it -- if you don't know the difference
between an array and a List, to use the Java terminology, and that
they are two different concepts in programming, then you don't have
the understanding to teach people about programming paradigms.

(And anyone who holds up Perl as an example of a consistent language is
clearly insane. Or possibly an alien from Alpha Centauri.)

-- 
Leif Roar Moldskred

[toc] | [prev] | [next] | [standalone]

#15238

On 12 juin, 22:58, Leif Roar Moldskred <le...@dimnakorr.com> wrote:
> micha <ludic...@gmail.com> wrote:
>
> > Yes it's inconsistent:
> > - because [] and ArrayList/Collections are 2 different ways to handle
> > vectors/lists (while there is only 1 in Python/Lisp/Perl
>
> To be rather blunt about it -- if you don't know the difference
> between an array and a List, to use the Java terminology, and that
> they are two different concepts in programming, then you don't have
> the understanding to teach people about programming paradigms.
>
> (And anyone who holds up Perl as an example of a consistent language is
> clearly insane. Or possibly an alien from Alpha Centauri.)
>
> --
> Leif Roar Moldskred

Leif, first let me thank you for your feedback (would it be blunt or
cute, it's still better than no
feedback at all)

You are right that I seem to 'teach people' what they already know and
moreover much better than me !!
I admit without shame that I'm far from being a Java specialist and I
apologize for my arrogance.

Anyway conceptually an array and a collection are the same
mathematical concept (like
explained gently by Robert Klemme) likewise an int and an Integer are
the same mathematical concept.
Moreover, in Java functions are not 'first class citizens' (like in
functional languages), and the idiom to
bypass this with 'anonymous inner classes' is an idiom which I find
very awkward...

I understand that these are not new argument but the answer of Robert
regarding data structures
for different usages (e.g: performance issues) reminds me the very old
'performance vs expressiveness' debate.

This debate started a long time ago with Fortran vs C, C vs C++ then C+
+ vs Java
and it's also I guess a reason why high expressiveness languages like
Lisp and Smalltalk
are still marginal in the industry (but as weird as it seems in
critical environment like nuclear
plants they are often the best choice).

Another reason is that Java is easier to learn and master than Lisp or
Smalltalk which
in turn raises the reason that universities chose to breed Java
developers rather than
Lisp/Smalltalk developers, all this recursively feeded by the growing
availability of
libraries / frameworks. PHP has also like Java a huge choice of
libraries / framework
but I doubt it would be chosen as a nicely shaped language by language
experts.
In fact all this seems related to the 'learning curve' (PHP is easy to
learn even by
non developers that's why it's so popular I think, same story with
VBA), but the
learning curve is shaped by the universities / industry / authors once
they 'adopt' a language

I found this article (http://azaidi.blogspot.fr/2008/02/reaching-
clojure-on-java.html) which even
if not very new seems still valid in my understanding. It says that
'Java is 21st century Cobol'
and that 'Java is good for enterprisy apps built by large teams of
trained monkeys skilled programmers'
It's pretty 'blunt' like you say and I'm sorry to offend the community
of Java developers who invested
so much of their time to become Java experts.

I guess in the late 80's, C experts did'nt like C++ because they fear
it will force them to drop a lot
of their assets learned on C and to invest time to learn a new
language (with the added drawback
of facing the defaults of a early language and the huge work to
rewrite'standard'  libraries like
networking, odbc, high precision calculus, GUI, etc...). The same
happened in the early 90's with C++ vs Java

So Java will sooner or later also be replaced by a new language with
actualized paradigms (Scala seems
 a good candidate at the time being). Then why not start to experiment
with new paths (especially
Adaptative Object Model which I'm pretty fond of if it was not clear
until now !!), my toy project is
maybe not the better way to experiment, the intent is only to raise
the motivation to experiment
new paths (at least for me it's a good tool to experiment, that's why
I thought i could be useful
for others too)

[toc] | [prev] | [next] | [standalone]

#15230

On 12.06.2012 22:03, micha wrote:

> Yes it's inconsistent:
> - because [] and ArrayList/Collections are 2 different ways to handle
> vectors/lists (while there is only 1 in Python/Lisp/Perl

The term is not "inconsistency" but "variety": different situations 
require different list like structures for efficient handling.  You make 
it sound like having only one data structure for an abstract concept 
would be a value in itself.  That might be true in mathematics but not 
in a software developer's real life(TM) because even though some 
requirements are identical (ordered storage) many others might not (e.g. 
varying size vs. fixed size).

> - because int is a primitive type (like in procedural languages)
> while Integer are Objects (the bypass to put integers in a Collection
> in fact)

Oh, Integer can serve other purposes as well: by having an object 
reference you can encode more information, namely "value absent" and 
"specific int value X".  The argument that Java is somehow deficient 
because it mixes primitive types with object types is not new.  The fact 
has some drawbacks (some of which were fixed with autoboxing) but it 
also has advantages.

>    instead all entities in Scala/Smalltalk are Objects (even
> functions), and scripting language (Python/Perl/PHP/Lisp) provide lazy
> typing and are thus
>    more consistent (even if at the price of more risk to write
> erroneous code which language laziness will let go through)

I don't see an increased risk here.  Strong typing prevents misuse.  And 
the term used for Ruby & Co. is "dynamic typing" not "lazy typing", 
while also these languages have strong typing (i.e. every object has a 
specific type all the time).  It's just that variables and expressions 
do not have a type which can be statically determined.

I would not call these languages more consistent.  It's just a different 
concept and mindset - dynamic vs. static typing.

Kind regards

	robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

[toc] | [prev] | [next] | [standalone]

#15232

On 6/12/2012 1:03 PM, micha wrote:

> Yes it's inconsistent:
> - because [] and ArrayList/Collections are 2 different ways to handle
> vectors/lists (while there is only 1 in Python/Lisp/Perl


Really?  In Perl, there's only one way to do something?  I admit I'm not 
an expert, but in my brief sojourn some 10 years ago I got the exact 
opposite impression.


> - because int is a primitive type (like in procedural languages)
> while Integer are Objects (the bypass to put integers in a Collection
> in fact)


So you invented a third way to represent these objects, which in your 
view is "more consistent?"

I think you're playing fast and loose with the English language here. 
What you're saying is at least non-obvious, and at worst just isn't 
true.  You might want to back up these statements with some reasoned 
arguments if you want anyone to believe them.


>    instead all entities in Scala/Smalltalk are Objects (even
> functions), and scripting language (Python/Perl/PHP/Lisp) provide lazy
> typing and are thus


The problem I see with your invention is it's likely to be even worse 
than Java's solution.  It's likely to be very difficult to optimize for 
the JVM.  Languages like Python and Lisp which provide "unified 
primitives" also provide ways of optimizing them.   In my view the way 
to get Java programmers to understand these techniques is to discuss 
them directly, not bolt a framework on to the language.

And honestly I think these concepts are well understood already.  It's 
pretty well known around here that C# provides excellent optimization of 
its built-in integers (which are objects like Java's Integer) and that 
those techniques could be ported to Java, if Oracle ever gets the 
resources to do it.  But in the meantime the suffering by Java 
developers is not too great, so we muddle on.

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.lang.java.programmer

csiph-web