Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast low-level
code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm. For
a motivational example (motivation for me anyway) see:A SQL Query Compiler http://scala-lms.github.io/tutorials/query.html. This approach is used in
LegoBase http://data.epfl.ch/legobase to very good effect. I think it is
very attractive if we can mix in relational declarative programming this
way with imperative programming that can supply large amount of libraries
and take care of side effects.
ATS itself is a code transformer (at compile time) but can it also easily
let users write a domain specific transformer (at run time) on their own?
Can ATS’s dependent type system provide a better tool?
Yes, I would think so.
The type system of ATS makes it highly suitable for dealing with (typeful)
syntax trees.
Also, I suppose that the compiler for a query language should itself be
efficient if it is used on-line.On Sun, Feb 8, 2015 at 6:03 PM, Haitao Zhang zht...@gmail.com wrote:
Yes that is what I vaguely understood as well and why I asked the question
here. However a LMS program is a user defined specializer that generates
another program so you can start with a query string and end with a C
program (another string). The underlying virtualized Scala is used to
ensure type safety. LMS also provides facilities to rewrite the code using
the IR. How can one achieve the same with ATS? ATS itself is a code
transformer (at compile time) but can it also easily let users write a
domain specific transformer (at run time) on their own? Can ATS’s dependent
type system provide a better tool?
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object
code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such
as common subexpression elimination out of the box, and it goes beyond
purely generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all
aspects can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very
good effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
RelC as described in this dissertation http://theory.stanford.edu/~aiken/publications/theses/hawkins.pdf is a
good approximation of what I would like to see in synthesizing code from
relational descriptions. The dissertation does not give implementation
details.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object
code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such
as common subexpression elimination out of the box, and it goes beyond
purely generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all
aspects can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very
good effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
RelC as described in this dissertation http://theory.stanford.edu/~aiken/publications/theses/hawkins.pdf is a good
approximation of what I would like to see in synthesizing code from
relational descriptions. The dissertation does not give implementation
details.On Sun, Feb 8, 2015 at 2:11 PM, gmhwxi gmh...@gmail.com wrote:
I took a quick look at LMS.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very good
effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This approach
is used in LegoBase http://data.epfl.ch/legobase to very good effect. I
think it is very attractive if we can mix in relational declarative
programming this way with imperative programming that can supply large
amount of libraries and take care of side effects.
Using LMS to generate efficient C code is incredibly hard; so LMS will
become more and more
complex; so people will find out later that writing efficient C code
directly is probably more cost-effective.On Sunday, February 8, 2015 at 6:20:54 PM UTC-5, H Zhang wrote:
Also I think one of the argument for LMS is that once code is transformed
into low level code (C for example) many optimization opportunities are
lost esp if one starts with high level representations (high order
functions, polymorphism e.g.), so their motto is “abstraction without
regret”. I don’t know how well that can be achieved but it certainly is a
very admirable goal.
On Sun, Feb 8, 2015 at 2:11 PM, gmhwxi <gmh...@gmail.com <javascript:>> wrote:
I took a quick look at LMS.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object
code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such
as common subexpression elimination out of the box, and it goes beyond
purely generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all
aspects can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very
good effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
Also I think one of the argument for LMS is that once code is transformed
into low level code (C for example) many optimization opportunities are
lost esp if one starts with high level representations (high order
functions, polymorphism e.g.), so their motto is “abstraction without
regret”. I don’t know how well that can be achieved but it certainly is a
very admirable goal.On Sun, Feb 8, 2015 at 2:11 PM, gmhwxi gmh...@gmail.com wrote:
I took a quick look at LMS.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very good
effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
Yes that is what I vaguely understood as well and why I asked the question
here. However a LMS program is a user defined specializer that generates
another program so you can start with a query string and end with a C
program (another string). The underlying virtualized Scala is used to
ensure type safety. LMS also provides facilities to rewrite the code using
the IR. How can one achieve the same with ATS? ATS itself is a code
transformer (at compile time) but can it also easily let users write a
domain specific transformer (at run time) on their own? Can ATS’s dependent
type system provide a better tool?On Sun, Feb 8, 2015 at 2:11 PM, gmhwxi gmh...@gmail.com wrote:
I took a quick look at LMS.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very good
effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.
I feel that the template system of ATS is already a kind of LMS.
Instead of using an intermediate representation, ATS uses a small set of
C and then relies on an optimizing C compiler to get efficient object code.
Compared to LMS, the template-based approach of ATS is more
direct and flexible.
I am not familiar with compiling query languages, though.
On Sunday, February 8, 2015 at 2:20:23 PM UTC-5, H Zhang wrote:
Because it enables abstraction without regret: the key idea is to write
very high-level
and generic programs that generate specialized and extremely fast
low-level code at runtime.
Programming abstractions that would usually be avoided in
performance-sensitive code
(objects, type classes, higher-order functions) can be used during
generation without
affecting performance of the generated code.
Why LMS ?
Because it is lightweight and modular: LMS is just a Scala library. With
types, it distinguishes
expressions that are evaluated now (type T) vs later (type Rep[T]).
LMS comes with batteries included: it provides many optimizations such as
common subexpression elimination out of the box, and it goes beyond purely
generative approaches by
providing an extensible intermediate representation that can be used to
implement
sophisticated domain-specific compiler pipelines.
At the same time LMS is hackable: since it is just a library, all aspects
can be
modified or extended to suit a particular purpose."
I wonder if ATS’s very expressive approach can support such a paradigm.
For a motivational example (motivation for me anyway) see:A SQL Query
Compiler http://scala-lms.github.io/tutorials/query.html. This
approach is used in LegoBase http://data.epfl.ch/legobase to very good
effect. I think it is very attractive if we can mix in relational
declarative programming this way with imperative programming that can
supply large amount of libraries and take care of side effects.