Jam Packed

Jam Packed is a revolution for the programmable web. Anyone can create, consume and share executable code safely. Build sophisticated serverless applications using this open cloud-agnostic technology.

Comment

Inspiration

I was inspired to create JAM Packed after seeing developers wasting incredible amounts of time working on technical infrastructure instead of implementing the features of their app idea. I watched startup teams and entrepreneurs alike grapple with solving technology related problems whilst their budgets and valuable time dissipated. In most cases, causing them to abandon their original idea.

Building and maintaining a full stack of technology is hard. So we, at JAM Packed, want to make developers lives easier.

I believe that when a developer has a lightbulb moment for an app they should be able to create what they want as quickly and easily as possible. Then focus on the users. Iterative feedback loops and updates to the software must be as easy as possible.

In addition, lateral thinkers and non-technical entrepreneurs, as well as those not fortunate enough to afford expensive IT infrastructure and technicians, should all have an equal opportunity to implement amazing solutions to problems (without unmanageable technical overheads).

In terms of web applications, the focus should be on implementing great ideas, unfettered by the time and costs associated with the burden of IT infrastructure. Achieving this goal, inspires me greatly.

What it does

JAM Packed, allows developers to build anything with just Javascript, APIs and Markup.

JAM Packed reduces the technical burden associated with creating and deploying web applications.

JAM Packed removes the need to perform the obligatory steps of setting up multiple development environments, initialising mobile phone coding platforms and needing to learn new proprietary coding languages and/or frameworks. JAM Packed takes web apps to the open web where they belong. Say goodbye to lengthy review processes and App store rules and hello to fluid serverless web applications; in web pages!

When using JAM Packed, developers do not need to own or maintain any server infrastructure. No networking problems, security configuration or database management. No servers. Just Javascript, APIs and Markup (JAM)!

JAM Packed operates exclusively on the open web via secure HTTP requests. An application can be as lightweight as a single static HTML page on a given user's device.

JAM Packed provides powerful Function as a Service (FaaS) functionality which is on par or superior to the leading cloud providers. However, JAM Packed is completely cloud-agnostic and therefore it does not have any of the traditional hoops to jump through. For example, there are no usernames, no passwords. There is no need to register and there are no proprietary authentication or access control mechanisms.

Imagine if a developer created an API which could:

  • convert an image containing a foreign language (like a restaurant menu or sign in a grocery store) to text, and then
  • instantly convert that text to another language

Well imagine no more, not only have I done this, to demonstrate the power and potential of JAM Packed, I have made the API freely available for any web developers to use on their web apps.

translation_demo

This is the power of JAM Packed. Developers can create any custom code which are launched as API endpoints. These endpoints are then made available for Javascript API Markup applications.

How we built it

We created a global environment where any user's code could be run safely via the open web, without having any effect on the other users who share the system. To achieve this, we built a custom stand-alone, stack-based Virtual Machine (VM).

We then created a public facing API which can access that VM. The API allows anyone to launch their code and then subsequently execute that code via the open web.

We used Postman for everything from testing to iterative development to documenting the use of JAM Packed via any and all languages that support HTTP requests.

Initially we supported basic requests for "hello world" examples. We then used Postman as an integral part of the development process, whereby we advanced to multipart-formdata requests and finally expanded the functionality to send and receive a host of content types; even binary files, raw bytes and so forth; which is perfect for image and video processing functions.

Many and varied web applications can be built using JAM Packed. The aforementioned food menu translation app prototype in conjunction with this article demonstrates how a developer only needs to create a simple web page with some Javascript and HTML Markup to achieve the most incredible results.

With JAM Packed, the web developer's app can quickly and easily call two JAM Packed API endpoints. The first which converts an image of a food menu to plain text (using OCR). The second which translates that text to 15 different languages. No phone app, no web servers, nothing for users to install, just quick useful functionality over the open web.

The great thing about JAM Packed's architecture is that developers are less likely to repeat code. For example, I, as the creator of the OCR and translation code have decided to launch this code (with a single secure HTTP request) as a free and open reusable Function as a Service (FaaS). Anyone who wants to add this functionality to their web app can simply call the OCR and translate endpoints, just as I have in my HTML/Javascript file.

Anyone, go ahead and create useful functions to power web apps such as this free anagram solver, or this free image processing site.

JAM Packed automatically generates a sha256 hash of code when it is either launched or updated. This way developers can be sure that they are always running the intended code by simply checking the current hash via a quick secure HTTP GET request. This is the hash for the OCR & translation code which we mentioned above. Perfectly simple and safe!

Functions can also be toggled between publicly accessible and private if the creator prefers to have exclusive access. Like all other JAM Packed interactions, this is done with a single secure HTTP request.

Challenges we ran into

One of the features of JAM Packed is that the user can specify that input parameters (for the user's executable function) to be fetched remotely. This is apposed to the user's device having to send the input parameters. This is very useful in cases where the user's device is working with low bandwidth. A use case for this would be the user executing an image processing function whereby the image is stored remotely and never actually downloaded to the user's device. Perhaps the user just receives a thumbnail of the finished result.

One of the challenges we ran into was that JAM Packed has limited control over the speed at which remotely fetched files are delivered. As we know, functions have signatures i.e. myFunc(param_1, param_2) whereby param_1 and param_2 need to be in the correct order. We overcame this challenge by implementing a simple convention whereby the user appends an underscore and a number signifying order. For example, there could be two header keys fetch_param_1 and fetch_param_2 (each would have a URL as the value, which JAM Packed would go and fetch).

We were able to test this quickly and efficiently (across all front-end app languages), thanks to Postman's automatically generated code snippets. Postman's automated documentation tooling also made it possible to easily communicate this underscore and numbering convention to developers in the simplest way possible. As a result this challenge was able to be solved with confidence.

Accomplishments that we're proud of

Ahead Of Time (AOT) compiled code is orders of magnitude faster than Just In Time (JIT) compiled code. We have made a monumental accomplishment, in that all code launched to JAM Packed is now automatically converted to an AOT executable binary. What this means is that, JAM Packed can now perform computationally intense functions in a fraction of the time usually taken. All functions run at native speeds. In addition JAM Packed offers developers with an opportunity to include high performance AI and Machine Learning (ML) functionality into their apps i.e. implementing image classification, face detection and so forth.

What we learned

We learned that developers who are building new applications for a particular market tend to make a lot of changes, on an ongoing basis. This ongoing iterative loop is a mechanism for developers to take user feedback and transform any new ideas and feedback into code; ultimately meeting the expectations of the users. We discovered that the traditional cycle of updating apps is untenable. We want the users to do as little as possible, not be confused and burdened with updating our app on their device. As a result we added a feature whereby the developer, making the app, can instantly hot-swap code live in production without any negative effects to the end users. All it takes is a single secure HTTP request, following which all users are synced with the newest build.

Postman features

We learned that we could easily create API monitors by simply selecting an existing collection. This now allows us to schedule API tests in an automated fashion and/or manually run tests. Whilst the official internal monitors for JAM Packed can service our own research and development. There is nothing stopping JAM Packed users from creating their own monitors to cater for testing their code changes (hot-swapping of their web applications logic). This is a brilliant feature which is paramount for reliability. It is also so very simple to set up and use.

What's next for Jam Packed

Potential monetisation

As mentioned above, JAM Packed performs code execution via a stack-based VM. The VM is able to provide statistics on each step in the execution of the given code, which it is processing.

What this means is that, JAM Packed can record computation in terms of effort. This provides an opportunity to easily implement a pay-as-you-go system to monetise JAM Packed, in the event that monetisation is ever required. JAM Packed could even operate as Freemium i.e. allow a certain number of requests per minute. Possibly, apps which exceed that standard rate limit are charged etc.

This is the most efficient and fair way to monetise JAM Packed. Users only pay for what they use. Unlike traditionally hosted apps, users are not paying for idle server time. If usage is low, then the costs are low; if not completely free.

At present, no monetisation has been implemented and, usage is free.

Broader integration with Postman - onboarding new users of JAM Packed

JAM Packed is an Open API which is made available to anyone on the web. Subsequently anyone can go ahead and implement all of the features provided by Postman. In fact we encourage it. Integrating Postman with JAM Packed will improve the development and testing of web applications which developers are building (on top of JAM Packed). Postman is an invaluable tool for development, testing, documentation and of course reliability.

JAM Packed is currently using Postman's API, Collections, Environments, Monitors and Mock Servers to improve what JAM Packed can offer to developers. Likewise, developers can take advantage of Postman's tooling to improve what their web applications can offer to their users.

We are very excited as we continue to explore Postman's amazing features.

JAM Packed is essentially infrastructure for developers. So whilst I am currently focussed on developing the core functionality of JAM Packed, in the future, I would like to create an exemplary "mock" web application which demonstrates how new up-and-coming web developers can integrate Postman into their own web applications (being built for their target market). Examples of this would be using Postman collections, as well as injecting dynamic variables (relating to the developer's app) and in addition setting up monitors to ensure that their app logic is always functioning as intended.

Try out prototype/example potential web applications

JAM Packed is kind of a meta offering. Whilst it is 100% an API. It is an API for developers to create their own APIs. Anyone can create the most amazing code and turn that into an API. In order to inspire developers, here are some examples of web applications that we have quickly built out as prototypes and examples.

Built With

Share this project:

Updates