Lambda the Ultimate

There is an ongoing controversy with Kowalski about the definition of "Logic Program":

* A logic program is one in which each computation step can be logically inferred.

* A logic program is written in logical clausal form and procedurally interpreted using forward and backward chaining (which was first done in the Planner programming language).

See the following references:

Wikipedia censorship

More Wikipedia censorship by anonymous Wikipedia administrator CBM

What is a Logic Program?

Visual programming has been an unfulfilled prophecy for years. As so many other areas, like virtual reality, artificial intelligence, or speech recognition, when the hype was high, the underlying technology wasn’t there yet.

But that was not its only problem…

Read more at Visual Programming Is Unbelievable… Here’s Why We Don’t Believe In It

Feedback would be appreciated.

Please see Video

Abstract:
Actors are becoming ever more important because of our increasing dependence on the following:

* coherent many-core (soon to be every-word-tagged) architectures, for which Actor concurrency is ideally suited.
* the Internet of Things, for which Actors are helpful in standardization.

In carrying out the above work, it is helpful to distinguish between the following:

* The Actor Model (which can be used to directly model all physically possible computation) is being increasingly used in industrial products, e.g., eBay, Microsoft, Twitter, etc.
* ActorScript (which is a particular very efficient and powerful programming system for implementing Actors) can be used to guide practical implementations in currently available programming environments, e.g., Erlang, Elixir, Java, C++, C#, JavaScript, Scala, etc.

Specific examples are discussed of how to use ActorScript and the Actor Model for engineering large-scale information systems in datacenters and for the Internet of Things. In particular, Actors can help avoid many pitfalls and problems that are commonly encountered.

Technical and engineering aspects of Actors for CyberThings even bear on possible resolutions of the current FBI/NSA proposal for mandatory backdoors in the Internet of Things.

Please see the following background reading:

* Articles on the following: the Actor Model, ActorScript, and Inconsistency Robustness
* How installing backdoors in the Internet of Things assists cyberterrorists

FlowScript configures decoupled, reconfigurable, late bound components, based on hierarchical state charts.

SIGPLAN is the ACM Special Interest Group (SIG) that focuses on Programming LANguages. It runs many of the field's academic conferences (ICFP, PLDI, POPL, SPLASH...) and its elected members are recognized researchers of the field (the chair and vice-chair are Jan Vitek and Jeremy Gibbons). It recently ran a survey on Open Access, questioning respondent's opinion on Open Access at large, Green vs Gold open-access, archival strategies, or indirectly-related questions such as "conferences vs. journals".

The results of the survey are summarized and present there: Who Owns Your Research: A Survey.

A harsh summary:

• Everyone knows Open Access is the right way to publish research.
• Seniors and Americans care about the ACM more than Juniors and Europeans.
• Many people would "just use Arxiv" (but then, why are so few of our field's article made available on arxiv?)
• Most do not care about Gold OA (where authors pay the publisher to make the article publicly available)
• There is no consensus on "conferences versus journals"

Is there any programming language theory that considers absolute upper bounds on how many lines of code (or bytes or whatever) a civilization can actively maintain (as a function of population size)?

Are such upper bounds low enough that the limit should inform programming language design?

the little nymph is for teaching purpose only.

it reuses the code and idea
of the early version of cicada-language,

to teach my friends
how to implement a interpreter
of a simple programming language.

I will use assembly language (FASM for x86-64)
to implement the interpreter.

the programming language to be implemented
is a threaded-code based (Forth-like) language.

the following shows how to define "if" & "else" & "then" by "define-macro"

: if
  << string[address, length] --
     address, string[address, length] >>
  *false?branch* save-into,jo-heap
  *current-free-address,jo-heap* xx|swap|x
  0 save-into,jo-heap
  end
; define-macro

: else
  << address, string[address, length] --
     address, string[address, length] >>
  *branch* save-into,jo-heap
  x|swap|xx
  *current-free-address,jo-heap* xxx|swap|x
  0 save-into,jo-heap
  << address, string[address, length], address >>
  *current-free-address,jo-heap*
  over sub *jo-size* div
  swap save
  end
; define-macro

: then
  << address, string[address, length] --
     string[address, length] >>
  x|swap|xx
  *current-free-address,jo-heap*
  over sub *jo-size* div
  swap save
  end
; define-macro

the following shows how to define factorial

: factorial
  << number -- number >>
  dup one? if
    end
  then
  dup sub1 factorial
  mul
  end
; define-function

for the code and more info ::

code on github
view the code in a fake emacs org-mode

the cicada nymph is for teaching purpose at first
thus many simplifications on features are made

and
the design of cicada language is influenced by scheme and forth and joy and smalltalk
I do not think, and will not say, which is "better" and "more powerful" than which
but some interesting features are to be designed for cicada language
I will post about them in the future ^-^

This is an amazing paper that I've been anticipating ever since I read the abstract about half a year ago.

ML is two languages in one: there is the core, with types and expressions, and there are modules, with signatures, structures and functors. Modules form a separate, higher-order functional language on top of the core. There are both practical and technical reasons for this stratification; yet, it creates substantial duplication in syntax and semantics, and it reduces expressiveness. For example, selecting a module cannot be made a dynamic decision. Language extensions allowing modules to be packaged up as first-class values have been proposed and implemented in different variations. However, they remedy expressiveness only to some extent, are syntactically cumbersome, and do not alleviate redundancy.

We propose a redesign of ML in which modules are truly first-class values, and core and module layer are unified into one language. In this "1ML", functions, functors, and even type constructors are one and the same construct; likewise, no distinction is made between structures, records, or tuples. Or viewed the other way round, everything is just ("a mode of use of") modules. Yet, 1ML does not required dependent types, and its type structure is expressible in terms of plain System F_ω, in a minor variation of our F-ing modules approach. We introduce both an explicitly typed version of 1ML, and an extension with Damas/Milner-style implicit quantification. Type inference for this language is not complete, but, we argue, not substantially worse than for Standard ML.

An alternative view is that 1ML is a user-friendly surface syntax for System F_ω that allows combining term and type abstraction in a more compositional manner than the bare calculus.

Basically, it unifies module and core languages, without dependent types, while supporting type inference without requiring more type annotations than OCaml (i.e. only on module or higher-rank types). It leaves applicative functors for future work.

An extended technical report and a prototype interpreter are available here.

/************************************************************************************/
ACM Conference on Systems, Programming, Languages, and Applications:
Software for Humanity (SPLASH'15)

Pittsburgh, Pennsylvania, USA
25th-30th October, 2015

http://www.splashcon.org

Sponsored by ACM SIGPLAN

/************************************************************************************/
COMBINED CALL FOR CONTRIBUTIONS
OOPSLA
Onward!
Workshops
Dynamic Languages Symposium (DLS)
/************************************************************************************/

The ACM SIGPLAN conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) embraces all aspects of software construction and delivery to make it the premier conference at the intersection of programming, languages, and software engineering. SPLASH is now accepting submissions. We invite high quality submissions describing original and unpublished work.

** OOPSLA Research Papers **
Papers that address any aspect of software development are welcome, including requirements, modeling, prototyping, design, implementation, generation, analysis, verification, testing, evaluation, maintenance, reuse, replacement, and retirement of software systems. Papers may address these topics in a variety of ways, including new tools (such as languages, program analyses, and runtime systems), new techniques (such as methodologies, design processes, code organization approaches, and management techniques), and new evaluations (such as formalisms and proofs, corpora analyses, user studies, and surveys).

Submissions Due: 25 March, 2015
http://2015.splashcon.org/track/oopsla2015

** Onward! Research Papers **
Onward! is a premier multidisciplinary conference focused on everything to do with programming and software: including processes, methods, languages, communities, and applications. Onward! is more radical, more visionary, and more open than other conferences to ideas that are well-argued but not yet proven. We welcome different ways of thinking about, approaching, and reporting on programming language and software engineering research.

Submissions Due: 2 April, 2015
http://2015.splashcon.org/track/onward2015-papers

** Onward! Essays **
Onward! Essays is looking for clear and compelling pieces of writing about topics important to the software community. An essay can be an exploration of a topic, its impact, or the circumstances of its creation; it can present a personal view of what is, explore a terrain, or lead the reader in an act of discovery; it can be a philosophical digression or a deep analysis. It can describe a personal journey, perhaps that by which the author reached an understanding of such a topic. The subject area should be interpreted broadly and can include the relationship of software to human endeavors, or its philosophical, sociological, psychological, historical, or anthropological underpinnings.

Submissions Due: 2 April, 2015
http://2015.splashcon.org/track/onward2015-essays

** Workshops **
The SPLASH Workshops track will host a variety of high-quality workshops, allowing their participants to meet and discuss research questions with peers, to mature new and exciting ideas, and to build up communities and start new collaborations. SPLASH workshops complement the main tracks of the conference and provide meetings in a smaller and more specialized setting. Workshops cultivate new ideas and concepts for the future, optionally recorded in formal proceedings.

Early Phase Submissions Due: 25 March, 2015
Late Phase Submissions Due: 30 June, 2015
http://2015.splashcon.org/track/splash2015-workshops

** Dynamic Languages Symposium (DLS) **
DLS is the premier forum for researchers and practitioners to share knowledge and research on dynamic languages, their implementation, and applications. The influence of dynamic languages — from Lisp to Smalltalk to Python to Javascript — on real-world practice, and research, continues to grow. We invite high quality papers reporting original research, innovative contributions, or experience related to dynamic languages, their implementation, and applications.

Submissions Due: 7 June, 2015
http://2015.splashcon.org/track/dls2015-papers

** Co-Located Events **

8th International ACM SIGPLAN Conference on Software Language Engineering (SLE)
Submissions Due: 15 June, 2015
http://conf.researchr.org/home/sle2015

14th International Conference on Generative Programming: Concepts & Experiences (GPCE)
Submissions Due: 15 June, 2015
http://conf.researchr.org/home/gpce2015

22nd International Conference on Pattern Languages of Programming (PLoP)
Submissions Due: 4 May, 2015
http://conf.researchr.org/home/plop2015

15th Symposium on Database Programming Languages (DBPL)
Submissions Due: 10 June, 2015
http://conf.researchr.org/home/dbpl-2015

Information:
SPLASH Early Registration Deadline: 25 September, 2015
Contact: info@splashcon.org
Website: http://2015.splashcon.org

Location:
Sheraton Station Square Hotel
Pittsburgh, Pennsylvania, United States

Organization:
SPLASH General Chair: Jonathan Aldrich (Carnegie Mellon University)
OOPSLA Papers Chair: Patrick Eugster (Purdue University)
Onward! Papers Chair: Gail Murphy (University of British Columbia)
Onward! Essays Chair: Guy Steele (Oracle Labs)
DLS Papers Chair: Manuel Serrano (INRIA)

Artifact Evaluation Co-Chairs: Robby Findler (Northwestern University) and Michael Hind (IBM Research)
Demos Co-Chairs: Igor Peshansky (Google) and Pietro Ferrara (IBM Research)
Inspirations Co-Chairs: Darya Kurilova (Carnegie Mellon University), Zach Tatlock (University of Washington), and Crista Lopes (UC Irvine)
Local Arrangements Chair: Claire Le Goues (Carnegie Mellon University)
Posters Chair: Nick Sumner (Simon Fraser University)
Publications Chair: Alex Potanin (Victoria University of Wellington)
Publicity and Web Co-Chairs: Craig Anslow (University of Calgary) and Tijs van der Storm (CWI)
SPLASH-E Chair: Eli Tilevich (Virginia Tech)
SPLASH-I Co-Chairs: Tijs van der Storm (CWI) and Jan Vitek (Northeastern University)
Sponsorship Chair: Tony Hosking (Purdue University)
Student Research Competition Co-Chairs: Sam Guyer (Tufts University) and Patrick Lam (University of Waterloo)
Student Volunteer Co-Chairs: Jonathan Bell (Columbia University) and Daco Harkes (TU Delft)
Wavefront Co-Chairs: Dennis Mancl (Alcatel-Lucent)
Web Technology Chair: Eelco Visser (TU Delft)
Workshops Co-Chairs: Du Li (Carnegie Mellon University) and Jan Rellermeyer (IBM Research)

SLE General Chair: Richard Paige (University of York)
GPCE General Chair: Christian Kästner (Carnegie Mellon University)
PLoP General Chair: Filipe Correia (University of Porto)
DBPL General Chairs: James Cheney (University of Edinburgh) and Thomas Neumann (TU Munich)
/************************************************************************************/

Can someone help me decode this comment from this post on Scala type inference:

On the other extreme, it is *possible* to do constraint typing in a nominal type system with subtyping, but you have to give up entirely on separate compilation. Type checking effectively turns into a special case of control-flow analysis, which not only makes the whole process exponential, but also completely kills the idea of reusable APIs and separately distributable libraries, since the entire program must be available to the type checker in order to definitively derive the union type at a particular declaration site.

Is that a theoretical result published somewhere? And when they say constraint typing, they mean "constraint-based typing" right?