Enigma Lav lovely-error

You were failed

Disclaimer

All info in this draft didnt come from my wild dreams. What I did is lurked for some research sitting in public university domains. It is amizing what highspeed unmetered internet connection and human with brains can do together. In short I just assembled some stuff to satisfy what I needed - A language for ~~ontology~~ software creation and how it ought to look in 21st century. You may see papers youself here

Intro

Let me be frank with you. All popular languages in use are bad. They all share a set of common design failures, plaguing some and sometimes all aspects of what programming discepline is meant to be - which is about making models that can be used by someone else to make more usefull stuff. Most of languages that have big repositories of useful frameworks, utilities etc do constrain the developer and its evolution in one way or another.

Swift is peice of crap. Since it's conception in 2013 no important features was added, and no problems was resolved. I regret about it, since there are points about which I am happy. It is one thing actually, visual aesthetic. Here are the list of features that would make swift the best.

Ban struct and explicit (fixed) generic signature: Remove <...> to designate a type variables. Instead take an approach of protocol associated types.

class Box {
  associatedtype Value
  var value: Value

Electable witnesses

Status: Active
Phase: (1/3)Gathering feedback

~Type Hierarchy - an ancestry representing what type is (class inheritance), and what type has (protocol conformance).

Introduction

Currently swift allows to declare rich protocol hierarchies, which serve the purpose of abstracting building blocks of software, while also providing the minimal dependency requirements between such blocks. Being a language that relies on paradigm of objects and inheritance, swift also provides capabilities to give these interfaces (or protocols in swift' terminology) the default implementation for its members (which makes them essentialy mixins). A teqnique known as retroactive moddeling can easily expand type' inheritance network to be consisting of multitude of entities that each can provide unique implementation of some functionality, without limiting the ability of being a customization point.

Introduction

The Rant

Since the beginning of a second half of the twentieth century the computer science has underwent through many discoveries and refinements(and still does), such transformations was happening to programming languages as well. Dozens of them of different flavors have emerged, whose purpose was diverse: from constructing artificial intelligence to translating mathematical formulas; there was some other wild applications. Whether fortunately or not, the graveyard now holds many of these blesses souls that died because of infitnes(yeap, DST is present here as well). As history unfold many better alternatives was offered and since 90 some of them - Java, Python, C++, C#, C, JavaScript - has sustained the presence on the ~~market~~ main stage and had become the defacto in many areas and received as much love as they did receive hatred. But while these has shown possibility of developing complex functioning systems, during the years of their existence, many disadvantages was revealed: Java

	```
	//when ever you create an object and do not specify mutability specification
	//S-CLISP treats that object with whole range (iso..tag) mutability
	object Box {} //is similar to
	object iso..tag Box {}
	//this means that you can instantiate object with the mutability you need.
	//there is 6 mutability sybtypes for every object
	//iso - in local scope: one writer, one reader
	//trn - in local scope: one writer, many readers
	//ref - in local scope: many writers, many readers