A Next-Generation Programming Language with No Reserved Words, Based on Category Theory
Sign is a revolutionary language that overturns conventional programming paradigms.
This guide covers everything from basic concepts to practical applications, designed for beginners.
Sign is a next-generation programming language developed by AI Infrastructure Trinity. Freed from traditional language design constraints, it adopts an innovative approach combining mathematical rigor with hardware integration.
Complete freedom of expression
Mathematical rigor
Hardware optimization
Most programming languages have reserved words like if, for, and class that cannot be used as variable or function names. This restricts freedom of expression and makes building domain-specific languages (DSLs) particularly difficult.
Traditional language designs make systems structurally susceptible to vulnerabilities like zero-click attacks and buffer overflows.
Many languages assume general-purpose CPUs and cannot fully leverage specialized hardware capabilities.
Sign has no reserved words at all. All identifiers are freely usable, with language syntax determined by context and the type system.
// Impossible in traditional languages
let if = true; // Error!
let class = "MyClass"; // Error!
// Perfectly legal in Sign
if = true; // OK
class = "MyClass"; // OK
Category theory-based design mathematically guarantees program composability and correctness.
Zero-click attacks are prevented at the language design level, with memory safety guaranteed.
In Sign, code meaning is determined by context and type information. Without reserved words, the same identifier can play different roles depending on context.
Example:
// 'map' can be used as both function name and variable name
map = [1, 2, 3] |> map(x => x * 2)
// Automatically distinguished from context
Sign's type system is based on category theory's concepts of "Objects" and "Morphisms". All computations are expressed as morphisms between types.
Represent data types
Int, String, User
Represent type transformations
Int -> String
User -> Email
Through category theory's fundamental principle of "morphism composition", small functions can be combined to build complex processes. This dramatically improves modularity and reusability.
// Function composition example
f: A -> B
g: B -> C
h: C -> D
// Composition
result = f >>> g >>> h // A -> D
// Or
result = h <<< g <<< f // A -> D
Traditional programming languages use reserved words like if, while, and class to define syntax. However, this creates problems:
Domain terms that collide with keywords force unnatural naming
Adding new features creates compatibility issues with existing code
Must memorize each language's unique reserved word list
Sign completely eliminates reserved words, determining syntax through the type system and context analysis.
// Python
if = 10 # SyntaxError
for = "text" # SyntaxError
class = MyClass # SyntaxError
# Workaround: unnatural naming
if_value = 10
for_text = "text"
class_name = MyClass
// Sign
if = 10 // OK
for = "text" // OK
class = MyClass // OK
// Natural naming possible
condition = true
loop = [1, 2, 3]
type = UserType
Without reserved words, building domain-specific languages (DSLs) becomes extremely natural.
// Building an SQL-like DSL in Sign
select = ["name", "age", "email"]
from = "users"
where = (user => user.age > 18)
orderBy = "name"
query = Query {
select: select,
from: from,
where: where,
orderBy: orderBy
}
// Execute
results = execute(query)
Category Theory is a field of mathematics studying abstract structures and their relationships. Sign applies category theory's fundamental concepts to programming language design.
Correspond to "types" in programs
e.g., Int, String, User
Correspond to "functions" in programs
e.g., Int -> String
Combining functions
e.g., f >>> g >>> h
Sign's type system satisfies the following fundamental category theory laws:
The order of function composition doesn't affect the result
(f >>> g) >>> h == f >>> (g >>> h)
The identity function acts as the unit element for composition
id >>> f == f
f >>> id == f
// Data transformation pipeline
// Type: String -> Int -> Bool -> Result
parseUser: String -> User
validateUser: User -> ValidUser
saveUser: ValidUser -> Result
// Build safe pipeline through composition
processUser = parseUser >>> validateUser >>> saveUser
// Type: String -> Result
// Usage
result = processUser("user_data_json")
// Type system guarantees:
// ✓ Input/output types match at each step
// ✓ Type safety of entire pipeline
// ✓ Compile-time type error detection
The DPL (Domain-specific Processing Language) Chip is a specialized hardware processor designed specifically for Sign. It realizes category-theoretic computation and memory safety at the hardware level.
Function composition, type checking, and memory management optimized at hardware level
Memory boundary checks and type safety enforced by hardware
Automatic parallelization of pure functions and dataflow optimization
Deterministic memory management without garbage collection
Sign considers DPL chip integration from the language design stage. This achieves performance and security impossible with traditional software optimization alone.
Integration with the DPL chip enables dramatic performance improvements for specific workloads:
Zero-click attacks are sophisticated attack methods that compromise systems without user interaction. Sign prevents these attacks at the language design level.
Sign's type system and ownership model eliminate memory-related vulnerabilities at compile time. Furthermore, the DPL chip performs hardware-level boundary checks and type validation, fundamentally preventing runtime attacks.
Sign adopts the concepts of Ownership and Borrowing to achieve memory safety without garbage collection.
// Ownership example
data = allocate(1024) // data owns the memory
process(data) // ownership moves
// data.use() // Error: ownership already moved
// Borrowing example
data = allocate(1024)
read(&data) // borrow (read-only)
data.use() // OK: ownership retained
Detected at compile time
Ownership system
Borrowing rules
Sign's powerful type system detects many bugs at compile time:
Prevent null pointer exceptions through the type system
// Explicit null handling with Option type
value: Option<String> = Some("data")
match value {
Some(v) => process(v),
None => handleError()
}
Explicit error handling with Result type
// Result type
result: Result<User, Error> = loadUser(id)
match result {
Ok(user) => displayUser(user),
Err(error) => logError(error)
}
Sign is an open-source project currently under development. You can participate through the GitHub repository.
Check detailed information and resources on the community page
Coming soon - check the GitHub repository for latest updates
Receive project updates
Share questions, ideas, and feedback
Understand language specifications and design philosophy
Contribute with code, documentation, and ideas
A next-generation programming language with no reserved words, based on category theory
We're waiting for your participation