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

Groups > comp.compilers > #1371 > unrolled thread

Hello v1.0.3 distributed programming language available (alpha)

Back to article view | Back to comp.compilers

Contents

  Hello v1.0.3 distributed programming language available (alpha) Boris Burshteyn <bburshteyn@amsdec.com> - 2014-09-09 12:38 -0700
    Re: Hello v1.0.3 distributed programming language available (alpha) glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2014-09-10 01:48 +0000
      Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha) Kaz Kylheku <kaz@kylheku.com> - 2014-09-10 04:58 +0000
      Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha) Martin Ward <martin@gkc.org.uk> - 2014-09-10 09:44 +0100
      Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha) anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2014-09-10 16:14 +0000
        Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha) Martin Ward <martin@gkc.org.uk> - 2014-09-11 13:16 +0100
          Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha) anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2014-09-15 08:07 +0000

#1371 — Hello v1.0.3 distributed programming language available (alpha)

Hello,

The distributed programming language Hello v1.0.3 (alpha) is ready for a free
download at www.amsdec.com <http://www.amsdec.com> . This version works on
64-bit Centos, Fedora and Ubuntu versions of the Linux OS on Intel x86_64
architecture.

About Hello

Hello is a general-purpose, object-oriented, imperative, protocol-agnostic
language for distributed applications. It combines the following unique
properties that set it apart from other distributed systems:

* The ability to create objects, access their data, and invoke their methods
on
multiple threads anywhere on the network, using simple Java-like syntax and
semantics.
* The language-embedded distributed architecture directly represents the
graph-structured underlying networking resources. The distributed elements
augment the single-host imperative language constructs, which represent the
linearly structured components of a von Neumann machine.
* Distributed operations include:
o queued asynchronous and synchronous synchronization requests,
o group traversals,
o intelligent, deep copy algorithms,
o asynchronous event processing,
o handling of timeouts and exceptions.

Hello Purpose

The Hello distributed architecture had emerged from the hands-on practical
experience of programming diverse distributed applications such as databases,
cluster monitors, protocol discovery, email and video servers. Because of
that,
Hello design pursues the following two goals:

* The general-purpose distributed language should provide superior
productivity
for developing a variety of efficient, reliable, and secure distributed
software.
* A mainstream programmer should be able to adopt this language in a short
amount of time.

Download Items

* Hello White Paper <http://0361e7b.netsolhost.com/hellowhitepaper.pdf>  --
explains the ideas that guided Hello design, illustrates Hello spirit on
sample
programs, explains translation technique, and lists language features.
* Language Overview <http://www.amsdec.com/hello_overview.pdf>  -- presents
most
language features via brief code examples.
* Hello Programming Guide <http://www.amsdec.com/helloguide.pdf>  -- contains
comprehensive language reference and user manual, with the explanations of
the
code examples from hello.install.
* hello.install <http://www.amsdec.com/hello.install> -- a self-extracting
binary archive containing Hello translator, runtime engine, package standard,
and a number of working code examples (this executable works only on Centos,
Fedora, and Ubuntu Intel machines).
* Shared Object Access <http://www.amsdec.com/AccessMethod.pdf> -- explains
how
Hello translator maps Hello objects into C++ objects inside the shared memory
segments.

Hello Feature List

1. Hello translator parallelizes distributed operations for runtime
efficiency.
2. Hello packages do not run inside a virtual machine. Hello translator
converts
them into shared binary libraries through the intermediary C++ invocation;
the
C++ translator can harness the power of its optimizer to optimize generated
C++
code.
3. Hello translator allows for embedding into Hello programs any C++ code and
linking with any C++ library.
4. Hello programs are written inside object-oriented type hierarchies
organized
in packages. Hello translator translates Hello programs into C++ programs and
then calls a C++ compiler to compile the generated C++ code into a 64-bit
binary
dynamic shared library.
5. Hello runtime engine dynamically loads the libraries and executes them; it
also transfers the libraries on demand across the network. Engines manage
memory
in partitions where the programs share runtime data. All this happens while
executing concurrent threads under control of the queues.
6. A runtime engine belongs to a host b a named collection of engines
running on
a single computer; any computer can run multiple hosts.
7. Engines from the same host access data from shared memory partitions
directly.
8. Engines from different hosts access each other data via the network.
9. Hosts connect, while engines transfer data, code, and control flow across
the
network transparently to the Hello programs.
10. Hello programs manipulate strongly typed primitive data, arrays, strings,
and class instances (objects).
11. Local operations are performed on data from a thread stack, the engine
heap
and host partitions; remote operations are performed by navigating references
to
objects from other hosts.
12. Hello provides safe data sharing in memory partitions and automatic
transfer
of packages across the network.
13. Hello offers object-level security identifiers and privileges.
14. It handles distributed failures via monitoring state label transitions,
catching exceptions, and timeouts.
15. Method arguments and return values are transferred to any host by
reference
or value following an intelligent, deep copy algorithm.
16. Remote and local objects assemble in groups for automated traversals.
17. Hello programs can build neighborhoods and paths of connected hosts and
use
them to communicate between disconnected hosts for better reliability,
efficiency and security.

Regards,

Boris Burshteyn

bburshteyn@amsdec.com

[toc] | [next] | [standalone]

#1373

Boris Burshteyn <bburshteyn@amsdec.com> wrote:

(snip)
> About Hello

> Hello is a general-purpose, object-oriented, imperative, protocol-agnostic
> language for distributed applications.

I have the books: "Handbook of Programming Languages" (a four
volume set), which are available used through Amazon or Half.com
for low prices.  (And I recommend them to readers here.)

Volume 1 is Object-Oriented Programming Languages, and volume 2
is Imperative Programming Languages. (Vol. 1 is about twice the
size of vol. 2.)

For that reason, I tended to think of imperative as exclusive
from object-oriented.  Not that you can't, or shouldn't, write
imperative programs in OO languages, but that it wouldn't be
used as a term in the description.  (Or, why is it that vol. 2
isn't called "Non-Object Oriented Languages"?)

-- glen
[I've always thought of OOP as being orthogonal to imperative,
declarative, or functional. But I'm not sure how much it matters.
Are there any functional OOP languages? -John]

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

#1374 — Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha)

On 2014-09-10, glen herrmannsfeldt <gah@ugcs.caltech.edu> wrote:
>> Hello is a general-purpose, object-oriented, imperative, protocol-agnostic
>> language for distributed applications. ...

> For that reason, I tended to think of imperative as exclusive
> from object-oriented.  Not that you can't, or shouldn't, write
> imperative programs in OO languages, but that it wouldn't be
> used as a term in the description.  (Or, why is it that vol. 2
> isn't called "Non-Object Oriented Languages"?) ...

Popular object orientation, like in Java, C++, Python, and whatnot,
is thoroughly imperative.

Objects have state, and support methods which mutate state.

This changing state is central to the collaboration among objects
in OO designs; OO is the organizational tool for managing the complexity
of all that state.

It is possible to have functional object-oriented programming;
everything is a constructor or non-mutating accessor.

An example of this is the treatment of numbers in the Common Lisp
Object System (CLOS). You cannot mutate an integer, ratio,
floating-point number or complex number. However, they belong to
classes linked by inheritance, and methods can be easily written in
the object system which specialize over various kinds of numbers. They
just return new numbers constructed based on their arguments.

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

#1375 — Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha)

> [I've always thought of OOP as being orthogonal to imperative,
> declarative, or functional. But I'm not sure how much it matters.
> Are there any functional OOP languages? -John]

Common Lisp has the Common Lisp Object System (CLOS) for object-oriented
programming. Scheme has Tiny-CLOS. It is possible to program
in an object oriented style in Haskell:
http://www.haskell.org/haskellwiki/OOP_vs_type_classes

--
			Martin

Dr Martin Ward STRL Principal Lecturer & Reader in Software Engineering
martin@gkc.org.uk  http://www.cse.dmu.ac.uk/~mward/  Erdos number: 4
G.K.Chesterton web site: http://www.cse.dmu.ac.uk/~mward/gkc/
Mirrors:  http://www.gkc.org.uk  and  http://www.gkc.org.uk/gkc

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

#1376 — Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha)

glen herrmannsfeldt <gah@ugcs.caltech.edu> writes:
>For that reason, I tended to think of imperative as exclusive
>from object-oriented.

One way to categorize programming languages is "imperative" ("do this!
do that!") vs. "declarative" ("x is the list of primes.").

"Object-oriented" is a property (or a collection of properties) of
some programming languages; the original object-oriented languages are
all imperative.  Some concepts have been transferred from
object-oriented imperative languages to functional languages, but
whether these languages are considered object-oriented probably
depends on who you ask.

In any case, "imperative" and "object-oriented" are everything but
exclusive.

>Not that you can't, or shouldn't, write
>imperative programs in OO languages, but that it wouldn't be
>used as a term in the description.  (Or, why is it that vol. 2
>isn't called "Non-Object Oriented Languages"?)

You would have to ask the editor.  "Non-Object Oriented Languages"
would describe everything in Volume 2-4.  My guess is that he did not
call Volume 2 "Non-Object Oriented Imperative Languages" because that
would be very long-winded, and since there is a separate volume on
object-oriented languages, it is clear that Volume 2 does not cover
that.

- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/

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

#1378 — Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha)

On 10/09/14 17:14, Anton Ertl wrote:
> the original object-oriented languages are all imperative

Simula, which dates from around 1962, is probably the original
object-oriented language, and is imperative. But Smalltalk,
for which development started in 1969, was a very early functional
object-oriented language.

--
			Martin

Dr Martin Ward STRL Principal Lecturer & Reader in Software Engineering
martin@gkc.org.uk  http://www.cse.dmu.ac.uk/~mward/  Erdos number: 4
G.K.Chesterton web site: http://www.cse.dmu.ac.uk/~mward/gkc/
Mirrors:  http://www.gkc.org.uk  and  http://www.gkc.org.uk/gkc

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

#1381 — Re: OOP vs imperative, was Hello v1.0.3 distributed programming language available (alpha)

Martin Ward <martin@gkc.org.uk> writes:
> Simula, which dates from around 1962, is probably the original
> object-oriented language, and is imperative.

Simula 67 is the first object-oriented language.  Earlier Simula
versions were not.

> But Smalltalk, for which development started in 1969, was a very early functional
> object-oriented language.

Smalltalk is an imperative language; e.g., it contains assignment and
its objects contain changeable state.  What makes you think that
Smalltalk is functional?

- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/

[toc] | [prev] | [standalone]

Back to top | Article view | comp.compilers

csiph-web