Poplar Programming Language

A simple language similar to Elm that can target all parts of the stack required to build Dapps, side-chains, and DAOs.

15+ years of research in distributed system architecture, programming language design, and cross-cultural communication. A strong background in physics and biology, which respectively provide clues into the constraints and possibilities of highly scalable collaborative systems.

[IMPACT]

Poplar will target the FIR intermediate language extending Plutus Core for all on-chain code. Any valid Elm code should be a subset of Poplar to allow people to write web-based frontend code in the same language as they write on-chain code. For off-chain backend code, Poplar will target the Pony programming language. Here are some of the benefits of using Pony:

1. Pony is an actor model language, promoting concurrency as a basis for system design
2. It has a powerful type system with Sum, Product, and Intersection types
3. Pony produces fast, non-blocking, highly scalable applications
4. It utilizes reference capabilities for memory safety, similar to Rust's borrowing system
5. It Can be used to ensure permission security through the use of object capabilities.

Elm uses what's called the Elm Architecture (TEA) to deal with changing states through monoidal composition of model and message pairs through the use of a single update function that takes in any messages that come from previous states of the model (Commands) or from outside the application (Subscriptions) and the current model to produce a new model along with any command messages to issue to the runtime system when the new state is reached. All effects are dealt with by Elm's runtime system, which allows for higher performance, because of referential transparency, which allows memoization during state transitions for diff-based updates.

The same features that make TEA work well in the context of a web app should also be applicable to a single actor, or a group of actors when parts of an update can be parallelized; and should also be able to model state machines to represent smart contracts.

The audience of this project is anyone who would want to produce scalable, full-stack applications that target the Cardano blockchain in order to enforce shared state across their system without having to deal with the cognitive load of using multiple different languages. Another benefit acquired from using one language to build out the full application stack is the ability to fully abstract away the communication layer between the different parts of the application. If you write a data structure that is valid on all parts of the stack, within a single homogenous codebase, it can be passed as a message between the structures that represent the different layers of the stack.

This project should make it easy to onboard Elm programmers for smart contract development on Cardano, as well as making the process much easier for new developers to get started.

One of my other proposals is about teaching people here in Malawi about Cardano and Dapp development. Having this language would make training much easier for me, and I believe this would also be true for others who want to bring more new developers to our ecosystem.

Some of the research involved in this project could also help other tool and language implementors on our platform improve their own systems, so the positive effects could go beyond just this project.

This project will definitely produce some good research that others might find useful in furthering the growth and accessibility of our ecosystem, though, the process of building compilers is a very complicated task. The full potential of this project is at least two years out.

There are techniques that can make the process simpler, as well as ways of patching in existing tools as part of the process before custom tailored solutions are developed, but these can take away from the best possible developer experience.

Patching in existing tools will probably be the best strategy in the short term, because later, these tools can be used to compare outputs with the custom-built solutions through things like property-based testing.

[FEASIBILITY]

The first 3 months will be focused on building up a specification, formal semantics, and documentation for Poplar as well as getting the codebase set up for people who might want to contribute to the project.

The next 3 months will be focused on getting the basic building blocks of the compiler set up and integrating with existing tools for the first iteration of the compiler.

Getting everything working the way I hope it to will almost certainly take longer than the 6 months of funding I'm asking for. If I'm getting funded for my work, I'll definitely take the time to host breakout rooms and do presentations of my progress on a regular basis.

I'm willing to commit to devoting 25 hours a week for a period of 6 months specifically to this project:

($30/hour)×(25 hours/week)×(4 weeks/month)×(6 months) = $18,000

This project will probably take at least 2 years to complete if I do it all myself. The main focus of the first six months will involve developing a detailed comparative analysis of the formal semantics for all the programming languages involved and working them into a spec for Poplar. It will involve getting the codebase set up so that people can get involved in collaborating with me, putting together a rich, searchable platform for documentation, building necessary helper libraries, etc... The formal analysis will probably take up most of the first 3 months and will help to clarify the best strategy for how to proceed further. Some code will be written to test out different ideas as part of the analysis phase.

I'm totally willing to continue working on this project without Catalyst compensation after six months.

Ken Stanton

A mostly hobbyist programmer since the age of 12 (26 years) with a focus on distributed systems, compilers, and how programming language semantics influence developer experience for different use cases. He loves to teach people about technical things.

Elsie Manase

A Malawian with a background in Logistics. She's going to be helping her husband (Ken) manage his time between teaching and working on his projects. Elsie's also interested in learning about Cardano and programming. She, and other people I'm working with here in Malawi, will help me test my ideas as I teach them Elm and decide how it should be extended to include all the features that I'm hoping for in Poplar.

[AUDITABILITY]

All code will be posted to GitHub and lots of work will go into building the documentation page associated with that repository.

Regular presentations will be available to those who are interested.

Success during the funded period of this project is mostly based on the quality of the information and ideas presented to the Cardano community and recorded in the documentation.

In the long term, beyond this funded period, my hope is to end up with a single stand-alone executable that provides what's needed for someone to initialize, build, test, and deploy smart contracts, scalable/networkable server systems, and web-based UIs with possible wallet integration.

The language itself should be as simple to use as possible without compromising the correctness guarantees given by currently available tools.

(I've never been funded by Catalyst since I started submitting proposals in Fund 2.)

Fund 2

Cardano and FP in Malawi:

https://cardano.ideascale.com/c/idea/323778

This was my original, unfunded proposal in Catalyst, back while I was still living in California. My hope was to move here to Malawi and start a business teaching computer science and Cardano, but due to the fact that I've had to solely rely on my own savings, any teaching I've done here has been informal and just to my group of friends. Getting funded for the current Cardano Tech Training in Malawi proposal would help me teach in a more public setting.

Fund 3

Marlowe and Plutus Mobile:

https://cardano.ideascale.com/c/idea/334477

This unfunded proposal was about creating a mobile interface that could allow people to easily build Marlowe ASTs on their mobile phones, with the hope of adding support for building up Plutus programs too, based on the information that was available at the time. This is related to my current Poplar Programming Language proposal. My hope was that Plutus would become something simpler than Haskell and stick more closely to what is available in the Core language without having a disconnect between Plutus Core's semantics and what language features exist in the off-chain code.

I wanted to work on this as a teaching tool here in Malawi.

Nmadi Space: A Digital Universe:

https://cardano.ideascale.com/c/idea/334508

This unfunded proposal was a game idea that I'm still playing around with. I sort of want to get something working with my current Poplar Language proposal before I start building a Cardano-based game, because it should greatly reduce the complexity required to build all the necessary features, which would involve a side-chain attached to Cardano through the use of Hydra heads, while relying on a different set of CAP theorem tradeoffs for localized high availability of game states, unlike what is required for monetary security on Cardano. Poplar should allow me to write it all in one language, if I decide to write a game like this.

Fund 4

(No Proposals)

Fund 5

Mobile Plutus and Marlowe Dev Tools:

https://cardano.ideascale.com/c/idea/352064

This unfunded proposal is an iteration of Marlowe and Plutus Mobile that I submitted in Fund 3. As such, it is related to Poplar in the current fund.

Fund 6

Distributed Collaboration Protocol (DCP):

https://cardano.ideascale.com/c/idea/369937

This unfunded proposal is directly related to the current DIMS proposal. It was focused on creating an open standard process for collaboration that focuses on scalability and limiting the amount of necessary knowledge for newcomers while helping to guide them to positions that fits their skills and desired role. DIMS is about building up a map of the idea space in the Cardano ecosystem that is easily traversable. If I add voice chat to DIMS, then finding an interesting conversation will be as easy as traversing the idea space through linked ideas. Other ways of connecting people may also be beneficial. These ideas were part of my research for DCP and may find their way into DIMS.

Plutus Integration with Pony Lang:

https://cardano.ideascale.com/c/idea/370089

The current Poplar Programming Language proposal is what I really wanted to do when I submitted this unfunded proposal. 

Elm Integration with Plutus:

https://cardano.ideascale.com/c/idea/370150

This unfunded proposal is also related to Poplar, since I want Poplar to contain the basic semantics of Elm as well as the functionality of Elm's Core library.

Fund 7

(No Proposals)

Fund 8

Distributed Idea Mapping System (DIMS):

https://cardano.ideascale.com/c/idea/401008

An idea mapping system that will be highly useful for organizing and creating documentation for other projects like my programming language, Poplar, as well as opening new doors for decentralized collaboration.

This will be written using the same technology stack as Poplar so that I can hopefully port its code to poplar for easier codebase maintenance!

Poplar Programming Language:

https://cardano.ideascale.com/c/idea/401069

This is my programming language that I want to design and write compilation tools for to lower the barrier to entry for Dapp, side-chain, and blockchain-based game developers.

This project will highly benefit from DIMS, because it requires doing comparative analysis on the type theories of many different programming languages, while DIMS still doesn't exist I'm going using a proprietary application called Obsidian to build up my connected knowledge base. It's free for personal use. My hope is to make DIMS more minimal than Obsidian, so porting to DIMS might take some work if too many Obsidian features are used.

Cardano Tech Training in Malawi:

https://cardano.ideascale.com/c/idea/401102

I live in Malawi, the warm heart of Africa, with my wife Elsie (a Malawian), and this proposal is to start a public study space here where people can come to learn about technical aspects and usage of Cardano as well as functional programming among other technical topics.

I plan to teach, and use the space to work on my other projects when I'm not teaching. My wife will take care of administrative details as well as learning more about Cardano.

Having tools like DIMS will enhance collaborative learning sessions and help students to build up their own project ideas from the process of finding new connections in the collective idea space.

My hope for Poplar is to give new programmers the chance to utilize the full power of the Cardano blockchain in their own projects with minimum possible cognitive load. During my time here in Malawi, I've taught some of my friends here the basics of programming in Elm. Elm has simplicity, stability guarantees, and the visual output of a language for the web. These things make it more accessible for beginners. The cognitive load of setting up the tool chain, understanding Haskell compiler extensions, monadic composition, template Haskell, and more, makes it very difficult to even consider for a programmer who has just started learning. Abstracting away complexity, and providing easy-to-use tools, without compromising efficiency, and the guarantees given by a pure functional language with a powerful type system could make teaching Plutus-based development accessible... even to teach to beginners here in Malawi.