Valaa is an object-oriented programming language, a collaborative development environment, a cloud file system and a runtime, all in one. Valaa is set apart from everything else by its global and unified data model that uses a software construct called Entity to represent everything from objects and classes to folders and entire applications. Valaa users are also represented as Entities. This makes Valaa an inherently social programming language.

"The complexity of software is an essential property, not an accidental one. Hence, descriptions of a software entity that abstract away its complexity often abstracts away its essence."

- Fred Brooks, No Silver Bullet, 1986

Valaa approaches visual programming from a very unique angle. The actual executed code is always present and accessible. To explain, visualize and control this code, Valaa users can create and attach visual user interfaces called Lenses to all Entities. They can control and edit the contained data structures using the same API calls as the code does. There is no difference between the Lenses that are used to access applications and the Lenses that are used to edit them.


6 R&D person-years
4 developers
3304 commits
3 active development projects

Central Valaa Components

Unified and Global Data Model

// Valaa object structure for a simple chat application

+ Message                         Entity (12 entries)
+ Channel                         Entity (9 entries)
- channel     =|> Channel         Entity (9 entries)
  MAIN_LENS   --> channel.vsx     Property --> Media application/vsx
  channelName === "Valaa lobby"   Property === string
  + messageLogEntry               Relation (7 entries)
  + participant                   Relation (4 entries)
  sendMessage --> sendMessage.vs  Property --> Media application/vs
  styles      --> styles.css      Property --> Media text/css
+ channelListEntry                Relation (3 entries)

Valaa introduces a global data model that unifies everything from folders, classes and objects to applications and even users themselves into programmable Entities.

With right permissions, any piece of data, functionality or media is accessible from any other application within the Valaa space.

Lenses

// channel.vsx | The user interface for the chat app

<div className={VSS(head.styles, "channel-root")}>
  <span className={VSS(head.styles, "channel-title")}> 
    Channel
  </span>
  {head[Relation.getAllTargets]("messageLogEntry")}
  <input 
    className={VSS(head.styles, "message-editor")}
    type="text"
    onBlur={head.sendMessage}
  />
</div>

Lenses are adaptive and personalized user interfaces of Valaa that can be attached to any Entity on any abstraction level.

Lenses is the innovation that allows logic and content be made accessible to anyone. They provide the means of building target audience specific and personalized user interfaces to Valaa content.

Valaa Language

// sendMessage.vs | Function to send a message

(messageBlur: Event) => {
  new Relation({
    name: "messageLogEntry",
    target: new Message({
      properties: { content: messageBlur.target.value },
    }),
  });
}

ValaaScript is a new textual programming language for computation and change in Valaa. It turns visual when paired with Lenses.

ValaaScript is fully compatible with JavaScript and you can easily integrate external libraries or your favourite web APIs to your application. With just a bit of prior JavaScript experience you should feel like home.

Ghost Instancing

// newChannel.vs | Instancing 'Channel' to create a new chat channel

(newChannelName: Event) => new Relation({
  name: "channelListEntry", 
  target: new Channel({ name: "channel", properties: {
    channelName: newChannelName.target.value, 
    styles: this.myCustomChannelStyle, 
  } }),
})

Ghost Instancing is our unique object instancing technology that is the groundwork for replacing mechanisms like classes and constructors.

Ghosts are self-contained, reusable and fully modifiable copies or instances of arbitrarily complex object compositions. They have almost nonexistent memory footprint until modified.

Sharing and Social Interaction

// Send a friend request to your chat partner

(participant: Relation) => new Relation({
  name: "FriendRequest",
  source: participant[Relation.target].hub,
  target: myPublicProfile,
  properties: { 
    message: `Hi! ${myPublicProfile.nickName} wants to be your friend.`,
    sharedChannel: participant[Resource.owner],
  },
})


Social interaction, collaboration and sharing are inherent capabilities of the unified Valaa infrastructure.

Users are Entities as well and relationships between them are created with the same primitives as relationships between data or applications. Your profile is a Lens displaying your public Entity the way you want it to.

Distributed Event Sourcing

// The actual event data of the friend request

{ "type": "CREATED", 
  "typeName": "Relation",
  "commandId": "2c5ab01d-e2f1-45d9-a540-e3177fee692e",
  "authorityURI": 
    "valaa-aws://ab98hia18a.execute-api.jove-north-17.amazonaws.com/valaa",
  "partitions": { "4bcefcbe-95dd-4849-9700-1df9bcf87802": { "eventId": 92 } },
  "initialState": {
    "name": "FriendRequest",
    "source": ["4bcefcbe-95dd-4849-9700-1df9bcf87802"],
    "target": ["3f37a25a-a4f9-4e5e-95d0-8d053734342c"]
} }

The backbone of Valaa infrastructure is a distributed event sourcing system. Data is stored as a series of events that modify the previous state.

Event sourcing moves resource-intensive computation to client devices and handles communications through fast and scalable IoT networks. This allows us to offer Valaa platform to developers and users for free.