Pepper programming language: Home | Explicit Ownership | Examples

You can jump straight to some Examples.

Pepper is a ficticious multi-paradigm programming language with the following capabilities:

  • NativePerformanceAndDeployability

Pepper will compile to native executable code, making it fast and easy to deploy.

Its runtime library will be small and will be capable of being statically linked, meaning installing a Pepper program can be as simple as copying a single executable file.

It will perform inlining and compile-time processing to allow high-level expression without incurring overhead.

It will support and encourage stack storage, pass-by-value and explicit ownership, reducing memory-management overhead.

Pepper will aim to allow and encourage being explicit in all areas. It is intended particularly to enforce explicit ownership of objects, so that memory management is automatic, but entirely within the control of the programmer.

  • ExpressivePowerAndMetaprogramming

Pepper will provide high-level concepts from languages like Lisp such as first-class functions and generic programming. Where such concepts may be resolved at compile-time to machine language instructions they will be, and only where resolution must occur at runtime will overhead be incurred.

  • SyntacticSimplicity

Pepper will follow Python’s lead in reducing the amount of unnecessary syntax and providing mechanisms to make the programmer’s intentions clear.

Its syntax will feel relatively natural to programmers from the C++/Java/C# and Python language families.

  • EverythingBuiltIn

Pepper will provide ways to build user interfaces and use other technologies such as the web, XML, email. It will provide a single "right" way and encourage programmers to use and improve it.

For example, Pepper will provide generic methods for creating windows, menus, buttons etc. which will be implemented using different underlying technologies on different platforms (e.g. win32, Gtk+, Cocoa).

  • MiniLanguages

Pepper will allow and encourage the creation of mini-languages (including Domain-Specific Languages) which are native to the language but fit the domain of the problem they are solving.