Hey everyone! I'm happy to provide another update on behalf of the Standard Library team. The big news this week is that we released a solution for use as a persistence layer inside of Standard Library APIs. Simple key-value storage that's easy to set up has been one of our most requested features, and I'm excited to show it to you!

From a community standpoint, we also had the pleasure of traveling to New Jersey last weekend to help out at Hack Princeton. It was our third time at HackPrinceton, and it's always a pleasure to be able to work with such talented and driven students from all around North America. I would like to give a special shout out to the winners of our prize, TextNet and Hoot, for a couple of really creative, and well executed, projects.

Thanks again to everybody who participated, as well as Princeton and the organizers. We had a fantastic time. Now, on to product updates!

Key-Value Storage

Because all APIs built on our platform are stateless, we often get questions about configuring persistent storage for use in more complex applications. We are happy to announce that we now have an in-house solution, in the form of a simple key-value storage API. The API is available as utils.kv exposes a simple interface and is ready to use with no configuration. It's as simple as:

const kv = require('lib')({ token: process.env.STDLIB_LIBRARY_TOKEN }).utils.kv;
await kv.set({key: 'key', value: 'val'});
let results = await kv.get({key: 'key'});

All Standard Library accounts have a table automatically associated with them, tied to their username. Right now, users are restricted to a single table as we roll out the feature, but you'll have the ability to use more in the future. You can try it from the documentation page, or from Code on Standard Library (embedded below, but that link opens it in a new tab).

That's All!

As usual, thanks for reading. If you have questions or need help join our join our Slack workspace or ask us on Twitter @StdLibHQ.

Steve Meyer
Software Engineer, Standard Library

Hey everyone, another week, another update! This'll be a short one, seeing as our last update was last week and we're moving a little bit faster than our traditional bi-weekly updates. However, we're happy to announce two major additions to Standard Library: we've added automatic code completion, and with the official switch for Node 10.x to LTS we've bumped our Node engine (runtime) to 10.13.0 on all Standard Library APIs.

Automatic Code Completion

Code Completion on Standard Library

With the recent introduction of e-mail autocompletion to Gmail, we decided we'd like to add an autocompletion engine of our own to Code on Standard Library. If you weren't already aware, Code on Standard Library is a bespoke in-browser development experience built from scratch (literally the ground up) by our team; we don't use Microsoft's Monaco which is based off of VSCode, we rolled our own.

Because of this, we're missing a lot of the "freebies" some in-browser development environments get for free with VSCode. We're determined to make sure this doesn't stay the case for long; Code on Standard Library currently has a minified payload about 25% the size of Monaco and has a bunch of additional UI features re: creating tasks, loading from templates and more.

Right now, the code completion engine supports about 60 different predefined patterns that should help you get started with building APIs using Node in your browser: we plan to expand it to be a more robust "intellisense"-like experience. You can play with it below!

Node 10

Now that Node 10.x has gone LTS, we've upgraded the Standard Library code execution platform to run Node 10.13.0 from Node 8.x. Not much else to say here, we hope you enjoy having the most recent runtime features available!

That's it!

That's all this week. As usual, thanks for joining us on our journey, and if you have questions or need help join our Slack workspace (click for invitation) follow us on Twitter, @StdLibHQ, or feel free to reach out directly to me on Twitter, @keithwhor.

Happy building!

Keith Horwood
Founder and CEO, Standard Library

Hey everyone! I'm pleased to be back with another Standard Library update.

To begin with, we're announcing a pretty big change in branding. With the success of Code.xyz, we're pleased to give it a new place on Standard Library. As of today, Code.xyz is now Code on Standard Library. We've moved it to a new URL, code.stdlib.com, and the old code.xyz domain now acts as a redirect to the new domain.

A little background: at the end of May we announced an investment from Stripe and launched Code.xyz, our in-browser API development experience. This was an experiment — a hypothesis — that we could introduce more people to API development if we made it as easy as possible from the web. We're pleased to announce that this experiment was successful. Developers, old and new alike, are now building APIs with the same frequency from the web as they are from our command line tools. To work towards standardizing (no pun intended) our products and features, we felt the move to code.stdlib.com was the right thing to do.

Along with this change, we've shipped some helpful new features: our editor now helpfully underlines complement braces, we've upgrades to our build (package installation) system, and we've added a much-requested feature: log access for collaborators you've added to your API.

We're also excited to announce that we've added two new members of the Standard Library team: Eileen Zhong and Scott Gamble!

Welcome to the team! Now, let's get into the update.

Underlined Complement Braces

As a general quality of life improvement, we've upgraded the code.stdlib.com rendering engine to underline complement brackets. Stay tuned for more rendering engine upgrades, there's more that's been refactored under the hood and this complement braces support is just the beginning.

Underline complement braces

Build System Upgrades

We've made two significant improvements to our build system:

  1. Code on Standard Library now supports imports for paths within NPM packages, such as const lodash = require('lodash/fp') for the functional programming variant of the popular lodash package.

  2. We've upgraded and are now using NPM 6 for package installation in our build engine, resulting in faster build times for large packages. Note that we already cache package installations, so subsequent deployments of an API within a short timeframe should go blisteringly fast as usual.

Collaborator Logs

In addition to being able to edit and deploy new versions of APIs, users with API collaborator access to an API can now see logs for it directly from code.stdlib.com or from their command line.

You can add collaborators, as well as grant or restrict access in other ways, via the Share button on your API's documentation page or directly from code.stdlib.com.

That's It!

We hope you enjoy these new features –– you can try them out right now at https://code.stdlib.com, or simply use it embedded below:

If you have any questions or feedback, come talk to us in our Slack channel! You can receive an invite by clicking here. We're also available on Twitter, @StdLibHQ, and you can follow me directly @Hacubu. Stay tuned for more exciting updates in the future!

We can't wait to see what you'll build!

Jacob Lee
Co-Founder, Standard Library

Hey everyone! Another Wednesday, another update. It's the start of the fourth quarter and we have a busy few months lined up for you in regards to building APIs with Code.xyz. Two weeks ago we brought you Scheduled Tasks right from your browser, and our very own Steve Meyer published an article on how to Deliver New xkcd Comics to Your Phone Daily with Node.js, Standard Library Tasks, and Code.xyz.

That said, we've been receiving quite a bit of customer feedback that testing API endpoints from the browser can feel a little cumbersome: it's difficult to switch between files to have to go test an endpoint, especially when you're working with an endpoint that has multiple dependencies (relies on other files). We're listening, and we've had the same frustrations ourselves. This week we're excited to bring you a brand new, upgraded API running and debugging workflow right from your browser.

Running API

Before we get into the product updates, we'd like to give a brief shoutout to both Functions 18 Conference in Toronto where I had the opportunity to give the keynote presentation, and Confront in Malmo where we had an amazingly warm welcome to a Code.xyz workshop we ran.

Thanks again for everybody who attended!

Upgraded API Running and Debugging

With the newest iteration of Code.xyz we've turned debugging API endpoints from your functions/ folder into a truly first-class citizen of the in-browser development experience and we've moved some things around.

  • We've removed Parameter Editing from a right-handed sidebar to the new Debugger on the bottom of the screen
  • In addition, we've updated logging in the Debugger to be a better experience that keeps track of function execution history

Parameters and Logging

  • We've also changed how running API endpoints works
    • There's a new endpoint selector beside the Run button
    • By default, the status is linked (green link icon)
    • This means that as you change which API endpoint file you're in (in the functions/ folder), the Debugger will automatically switch to the correct endpoint
    • If you choose a file that is not in the functions/ folder, the endpoint selector will lock on the last modified endpoint
    • If you click the endpoint pin (green link icon) you can manually select which endpoint you'd like to run
    • to re-link the selector to your file selection, simply click the endpoint pin once again
  • Additionally, we now inline API endpoint call responses in your logs to maintain session records as you play with Code.xyz
  • Check the .gif below for examples of the above features in action!

Running API

  • Finally, we've changed how markdown previews work: any file that's identified as a markdown document will be given a preview in the bottom right of your editor, you can expand it by click the eyeball icon in the bottom right

Markdown Preview

That's it!

As per usual, if you'd like to play with the new features then head on over to code.xyz/?sample=t to load a sample project, or simply play with the editor inline as a part of this blog post below:

We hope you enjoy the new features, they should make API iteration and development a heck of a lot smoother. If you have any questions, please don't hesitate to come join our Slack workspace (click for invitation), follow us on Twitter, @StdLibHQ, or feel free to reach out directly to me on Twitter, @keithwhor. Always appreciate great feeback!

Happy building.

Keith Horwood
Founder and CEO, Standard Library

Hey everyone, I'm excited to have the opportunity to announce another update on behalf of the Standard Library team!

This past week we added scheduled task support to Code.xyz. Scheduled tasks have a huge variety of applications -- checking a webpage for daily changes, sending SMS reminders, creating a weekly dump from a database, and more. Regardless of your use-case, it's never been easier to schedule function executions, either with a simple interval (minute, hour, day, week) and frequency, or with a cron expression.

In other news, we are headed to Functions 2018 in Toronto at the end of this week. If you're in the area, make sure you stop by and say hello!

Schedule Tasks (API Execution) from Code.xyz

Scheduled task management is now available from Code.xyz. You can find the scheduled tasks integration right next to the Code tab, in the top-left corner of the screen.

Once there, you'll see all of your active tasks running on the left. To create a new task, pick an API from the selector on the right side of the screen.

Then you pick the endpoint (should your API have more than one), give the task a name and specify when you would like to run your task. Scheduling is quite flexible -- simply specify an interval, frequency, and start time (once a minute, twice an hour, four times a day, every Friday at 5PM), or, for more complex timing, use a cron expression. You can find documentation for cron syntax here.

Click Schedule Task - and you'll see your new task appear in the left panel!

If you would like to stop a scheduled task, you can remove it by clicking on its respective trash bin icon in the left panel.

Thank You!

As always, we appreciate your continued support and hope that you discover some solid use-cases for scheduling APIs! If you would like to contact us, please feel free to join our Slack workspace, or follow us on Twitter, @StdLibHQ.

We can't wait to see what you build!

Steve Meyer
Software Engineer, Standard Library

Hey everyone! It's Jacob from the Standard Library team with another bi-weekly update.

I'm pleased to announce support for directly sharing your APIs to email addresses, cold start mitigation for members of our team subscription plan, and improvements to scheduled task management from our CLI.

A few months ago, the team also attended ServerlessConf in San Francisco, where our founder and CEO, Keith, gave a talk about Standard Library and where we want to head from here. It went live recently, and it's definitely worth a watch:

We'll be headed to Functions 2018 in Toronto next week, so if you're in the area, come say hi! And now, without further ado, let's dive into the platform updates!

API Sharing to Email

It's now easier than ever to share APIs you build on Standard Library. Simply enter your friend or co-worker's email address, and we'll send them an invitation to check out your API! They'll be able to choose which Standard Library account they'd like to use to access your API, and you can set whether you'd like to allow them to just view your API's documentation or view and collaborate on the code itself.

You can still search for users by their Standard Library usernames, and you can even mix types of invitations within the same share.

Cold Start Improvements

We're happy to announce API cold start mitigation as a feature for users on our team subscription plan. This automatically applies to all of a user's deployed APIs, and should ensure that first executions of APIs after a long period of time will be faster.

Scheduled Task CLI Improvements

Scheduled task creation from the CLI now supports cron expressions and invocation of APIs deployed to development environments (i.e. @dev). Simply use the lib tasks:create command with the name of the API and follow the prompts.

Additionally, listing your tasks with lib tasks will show when your task will be invoked next.

Thank You!

We appreciate your continued support, and hope that you find these improvements helpful as you create your APIs! If you would like to contact us, please feel free to join our Slack workspace, or follow us on Twitter, @StdLibHQ.

We can't wait to see what you'll build!

Jacob Lee
Co-Founder, Standard Library

Hey all! I'm thrilled to announce another bi-weekly update from the Standard Library team.

We've added Code.xyz authentication support so you can test private or authentication-reliant APIs from your browser as you iterate on them, stack traces to runtime errors for dev APIs to aid debugging, and a feature allowing you to download your API's code as a tarball directly from Code.xyz.

We also traveled to Canada last weekend to help hackers at HackThe6ix, Toronto's leading summer hackathon. We met some amazingly talented, enthusiastic people, and saw some awesome projects built on the platform!

Let's dive in!

Authentication From Code.xyz

You can now select a library token you'd like to use to make authenticated requests directly from Code.xyz. This makes it simple to test access-restricted APIs, and/or APIs that require information like the username of the requester, right from your browser! Simply hover over your username in the top right of the editor and select Set Active Library Token:

You can see what your currently active token is, change your active token by clicking a different token in the menu, or unset your token if you'd like to make unauthenticated requests by clicking the same token you have set.

If you'd like to create a new token or expire one of your existing ones, simply follow the Manage Tokens button in the bottom of the dialog, or go to the library tokens section of your Standard Library dashboard.

Try it out below!

Stack Traces for Dev APIs

To help debug tricky issues, we've added visible stack traces to any API that's called in a non-release (i.e. development) environment (for example, dev). This information is available via an additional field in the error object returned by Standard Library error responses, stack (accessible from our client libraries as err.stack). For example, executing the following API:

Will now result in the following error:

Errors that released (i.e. versioned, 0.0.0, 0.1.0, etc.) APIs throw will not return the stack field, but are still available in your service's API logs.

Code.xyz Tarball Export

You can now download your API code directly from Code.xyz! After opening your project, simply right click its header in the file explorer and select Export as Tarball.

Thank You!

That's all for this week's update — we hope you find these features and improvements useful as you build! If you need to contact us, please feel free to join our Slack workspace, or follow us on Twitter, @StdLibHQ.

We can't wait to see what you'll build!

Jacob Lee
Co-Founder, Standard Library

Hey everyone! Welcome to another bi-weekly update from the team at Standard Library. This week we have something special for you: we've updated the API Project browsing and Source (template) finder on Code.xyz. We've also managed to knock out a few long-standing bugs, and made a few usability improvements. Excited to show you!

Before we get to that, we'd like give a really special thank you Murshid Hassen (@MurshidHassen) for his kind words this week — we've been working really hard to ship updates and every piece of receptive feedback makes the team feel awesome!

Again, thank you! If you enjoy using our products, feel free to let us know on Twitter.

Code.xyz Updates — Bug Fixes, New Project UI

Bug Fixes and Usability Improvements

  • Fixed a bug where fonts would be resized on orientation change (iOS)
  • Added the ability to "create a folder" (creates a directory with a single empty file)
  • Added previously released Share API Dialog to Code.xyz
  • Added the ability to direct link APIs with ?service= parameter
  • Moved Publish button into actions bar at bottom of API editor

New Project UI

We've updated our Project / Source (Template) management UI for a better landing experience on Code.xyz.

Our Old Project Finder was a pop-up dialog...

Old Project Finder

And our New Project UI is a full landing page experience, with integrated source loading as well.

New Project UI

If you'd like to check it out yourself, you can visit Code.xyz in your browser, or simply check out the embed below. Please note: on smaller screen sizes there's a <> Projects and <> Sources button to switch between interfaces, including in this embed.

Thank You!

That's it for this blog update, we hope you enjoy playing with the new UI! As we continue to bring API collaboration front-and-center you'll see more of a focus on sharing and API sources (templates), this is just the beginning. As usual if you need to contact us, please feel free to join our Slack workspace.

Happy building!

Keith Horwood
Founder and CEO, Standard Library

Hey everyone! Steve here from Standard Library. I'm excited to make the first non-founder post on our blog! While we've promised an update at least once every two weeks, we've been firing on all cylinders since ServerlessConf San Francisco. It's only been a week since our last update, but we're so excited about what we're working on we wanted to get it to you as fast as possible.

I am happy to introduce two new features to Standard Library and Code.xyz — improved error tracing for better observability of your APIs running on our platform as well as a brand new project selection and management interface. Here it all is!

Enhanced Error Tracing

Newly deployed APIs on Standard Library now automatically log error stack traces and full messages to aid debugging. This is especially useful for testing and gaining visibility into webhooks, where you are not testing your function directly from Code.xyz or your command line.

For example, calling the following API:

buggy api one

Will result in the following logs:

buggy api one stack

The stack trace extends to other files too. For example, this API:

buggy api two

Results in these logs:

buggy api two stack

Both normally thrown or returned errors and uncaught exceptions will show up in your function logs, which are available from your Standard Library dashboard or from your command line. You can check out the docs for full details here.

Updated Project Management

When autosaves were added to Code.xyz a few weeks ago, we noticed that the current way of selecting projects was becoming a bit cluttered. We updated the project selection window to group every version of a service together including autosaves, development APIs and released APIs. You can find the new finder by hovering over your username in the bottom left corner of Code.xyz and clicking Open Existing API.

new project finder location

Once your projects load, you can click or arrow through to expand a service. It will display all available versions that you can fetch, sorted by the last time that version was updated. For instance below, you can see that I have access to several versions of Code.xyz available to download (did you know that Code.xyz was built on Standard Library?).

new project finder

If you would like to check out the new UI yourself, feel free to play with an embedded version of Code.xyz below!

Thank You!

As usual, thanks for taking the time to read our updates! You'll start reading updates from more of our team as we continue to grow. If you're looking for a new role, please don't hesitate to check out our careers listing. Stay in touch with us by joining our Slack workspace, or follow us on Twitter, @StdLibHQ.

Enjoy,

Steve Meyer
Software Engineer, Standard Library

Hey everyone! Today we have a special update and release live from ServerlessConf San Francisco. Since launching API Permissions two weeks ago the team has been hard at work iterating on our latest feature: improving the API Sharing (permission enabling) workflow for your Standard Library APIs built with our command line tools or Code.xyz.

To start with, we're super excited to be sponsors of ServerlessConf San Francisco this year. The event has been fantastic, with hundreds of developers from across the world coming to visit and chat about the future of serverless web technologies. We're very grateful to be working in this space with such amazing people! Here's a peek of the Hackathon we helped with on Sunday:

Without further ado, we're also thrilled to show you what we're rolling out this week!

Share APIs

We've updated our API Permissions dialog and menu to enable you to share APIs with other developers or within your organization more easily. You'll notice our old Manage Permissions button has been replaced with a Share button on any API page you own.

Share APIs

Upon clicking this button, you'll be given two options: you can invite somebody to execute your API and view documentation or collaborate on the underlying code.

Dialog Example

Execute API and View Documentation

This flow is intended for read-only (and execute-only) access to your API: for example, clients or partners you're iterating on an API with and need feedback from. You don't want these people to worry about the code and implementation of the API, but would like them to be able to use and play with your API.

View API Docs Options

You can choose to share this API with everyone (creates global, public access — not restricted to a Standard Library account) or add specific users. Further, you can decide which development environments this applies to. API releases are immutable, versioned releases of your API and are encouraged to be shared, but development environments should typically only be shared with clients or people you're working on your API with, you don't always want to share how the sausage is made!

You may also notice an Advanced button, with which you can use to set more granular permissions like restricting access to a specific IPv4 address or range and controlling execute / view documentation access separately.

Once you've shared your API via this mechanism, e-mails will be sent to Standard Library developers that you've granted permissions to. You'll also be redirected to global access management which looks something like this:

Access Management

Access refers to Execute, View Documentation and Deployment privileges and Scope refers to the types of APIs available: release only, or development environments as well.

Collaborate on Underlying Code

This flow is intended to invite teammates and other developers to collaborate on your API code. They'll be given access to the underlying API implementation, have full access to both API execution and documentation, and be able to access your API using Code.xyz.

Collaborate on Code

Once selected, these developers will be invited to modify and work on your API with you. Think of this like inviting people to work on a Google Doc with you with full modification privileges. For those of you that have used Standard Library and Code.xyz at hackathons, this is the easiest way to collaborate with any sort of team member without explicitly creating a team account. Have fun! You can play with Code.xyz and build your own Standard Library API below:

Thank You!

As usual, thanks for taking the time to read our updates, and thanks for being part of our journey at Standard Library! We're very happy to have you with us and have such great support from our growing developer community. Stay in touch with us by joining our Slack workspace, or follow us on Twitter, @StdLibHQ.

We look forward to building more with you!

Keith Horwood
Founder and CEO, Standard Library

Hey everyone! It's that time again. It's been two weeks since we launched API Autosave as a part of Code.xyz, saving a lot of developers from losing the API building they'd be doing in their browser if they forgot to deploy. Today, we're launching a feature that should help people building Slack applications and more that want to restrict their API usage to a subset of IP addresses and / or authenticated users.

Introducing API Permissions

  • API permissions allow you to delegate access control on a per-API basis within Standard Library
  • These apply to APIs built from the Command Line or Code.xyz
  • The interface is available from both our dashboard and individual API pages on Standard Library
  • You can enable permissions, per user, IP (IPv4 address) or both to the following granularity;
    • API Execution: Can execute the API from the HTTP(S) endpoint or using SDKs
    • Documentation: All of the above, can also read documentation on Standard Library for the API
    • Deployment: All of the above, can also retrieve code and deploy new versions of the API using our CLI or Code.xyz
  • The default for permissions based on user type are as follows:
    • All users, all API development environments: API Execution
    • All users, all releases (unpublished): API Execution
    • All users, all releases (published): Documentation
    • All members of an organization, all APIs: Deployment
    • Owner, all APIs: Deployment
  • Basically — if you're part of an organization or own an API, you have Full Access (Deployment), otherwise you can only see published releases
  • All APIs on the platform are accessible via HTTP(S), ACLs used to be configurable as a deployment feature, we've now turned this into a platform feature

Enabling Permissions from Standard Library

Manage Permissions Button

  • Click to add permissions...

Manage Permissions

  • In the top section you'll have the ability to Select a user, Select an IP range, what Permission Level you're enabling, and Environments the permission applies to (releases or development environments)
  • By creating a permission entry, you whitelist the specific user x ip x permission x environment combination

Enabling Permissions from the Dashboard

  • Visit your dashboard API services page
  • Select your API that you'd like to modify the permissions of
  • Follow the steps above with the dashboard interface

Dashboard Permissions

Community Updates

Reflection: ServerlessDays London

In other news, we had the wonderful opportunity to speak and show off Code.xyz as ServerlessDays London just over a week ago. Thank you to everyone who showed up, it was a wonderful event!

Upcoming: ServerlessConf San Francisco

We also think it's a great time to mention we're sponsoring ServerlessConf San Francisco! Come join us on July 29th at the Hackathon where we'll be giving away prizes or throughout the conference from July 31st, 2018 until end of the day on August 1st, 2018. We'll be giving away free t-shirts and swag as well. Looking forward to seeing you!

Thank You!

Thanks for keeping up to date with Standard Library and Code.xyz development! If you'd like to keep up with the latest news, follow us on Twitter, @StdLibHQ and if you're looking for help don't hesitate to join our developer Slack Workspace for help (click here for an invitation).

Thank you for reading and being a part of our journey,

Keith Horwood
Founder and CEO, StdLib

Hey everyone! As promised, we're committed to keeping our community updated on a bi-weekly cadence by 9AM PT on Wednesday mornings. The last two weeks have been a flurry of activity for the Standard Library team — last week I was in Reykjavik, Iceland to present at BlueYard's Future of Software Development Conference, this week we'll be at ServerlessDays London, and on top of that, there have been some recent festivities for our North American friends and colleagues. July 1st was Canada day, and now that today is the 4th, happy Independence Day to our American community!

We've gotten off to quite a celebratory start this week. Following that excitement, we're happy to talk to you today about a very important update to Code.xyz. Since the launch of Code.xyz last month, we've had a few developers lose their API development progress by navigating between pages or hitting "back" in the web browser accidentally with no way to recover their work. We've now fixed this problem — at the popular request of our community, we've added a brand new cloud-based API autosave feature. In addition, we've also added the ability to delete existing APIs from within the Code.xyz API selection screen.

Code.xyz Feature — API Autosave

  • All API projects you work on via Code.xyz will now be autosaved every time you hit the orange "save" button in the bottom right

  • This feature replaces the previous behavior of being a local, temporary save only
  • You can load autosaves from the "Open Existing API..." prompt, which shows any actively deployed (and live) APIs, along with cloud autosaves at the top

  • We've also added the ability to delete both APIs and autosaves from this prompt — be careful, this cannot be undone!
  • To remove an API, simply right-click it in the "open existing API..." dialog

Try it out!

Here's our embedded sample API. You can try out API autosave by changing the file in any way you'd like and hitting Save in the bottom right. You can then try to open your Autosave by going to your user menu in the bottom left and hitting "Open Existing API..." — the autosave should appear at the top.

Thank You!

We hope you enjoy — we have a lot more coming, and we'd love to hear your feedback. Drop us a line any time on our community Slack workspace (click for an invitation). To the thousands of developers building APIs with us since we've launched Code.xyz, thank you!

Happy to have you with us,

Keith Horwood
Founder and CEO, Standard Library

Hey everyone! As promised in our last blog post, it's been two weeks, so it's time for an update on the progress of both Code.xyz and Standard Library. We are thrilled to be able to share that we hit a milestone earlier this week, more than 50,000 APIs have now been deployed to Standard Library — both using our command line tools and Code.xyz. These include Slack bots, Stripe stores, Messagebird's SMS APIs, everything you need to know about mountains via AscenDB's API, and tens of thousands of private workflow automation APIs (task scheduling, e-mail outreach, web scraping, you name it)!

If you've heard about Code.xyz and what we're doing at Standard Library but have no idea where to get started, our very own Janeth Ledezma Sanchez has you covered:

Now — the good stuff! Our community Slack workspace has been buzzing. There are all kinds of feature requests we've been itemizing and knocking out with a lot of interest around GitHub integration. We're pleased to announce that we've been listening and working hard to make Code.xyz a more integrated experience with your existing developer tools and workflows.

Code.xyz and Standard Library Updates

Export API Functions as GitHub Gists

  • Functions for APIs as Components: Export as GitHub Gist
    • We now offer the ability to export any individual function in your functions/ directory (API endpoints) as a GitHub Gist
    • This feature effectively turns functions / API endpoints into shareable components
    • You can use this functionality to share Code.xyz examples with others, or keep your own set of commonly used endpoints to mix-and-match in future API projects
    • This functionality is easily accessible by right-clicking the function you'd like to export from the TreeView or right-clicking the active file contents in the editor

Export as GitHub Gist

Import from GitHub Gists

  • Import from Gist: Load from URL
    • Once you have a gist, you can share it with others by sharing the link code.xyz/?gist=username/gistid0000 (where gistid0000 is the automatically generated unique gist id provided by GitHub)
    • The example below (and embedded at the bottom of this blog post) is located at https://code.xyz/?gist=keithwhor/6ad11a67add5860a75b0e8b0e3694af9

  • Import from Gist: Load from your Gists
    • By right-clicking in the Code.xyz TreeView, you can add any Gists you'd like to a project that you've previously saved from Code.xyz
    • These Gists can be used as "API function templates" or components as described above

Import Functions

Import Functions Dialog

API Documentation Introductions Made Easy: API.md

  • Platform Update: API.md
    • We've separated out internal and external documentation for your APIs into an API.md and README.md file
    • README.md is information for internal API development - you can share secrets around implementation details here
    • API.md is for end-users that you want to consume your API - it is used to generate documentation (namely, the API description and how to) on Standard Library

Thanks — try it out!

Want to try out our new features? Check out the example below: it's loading a Gist from my GitHub account that proves that [a == 1, a == 2, a == 3] can return [true, true, true] in JavaScript!

Thanks for reading, and stay tuned for more GitHub integrations!

Keith Horwood
Founder and CEO, StdLib

Last week we launched Code.xyz, the online code editor for building APIs to an amazing response — more than 2,500 APIs have been deployed using it in less than a week — and from everyone on the StdLib team, we wanted to say thank you. We're excited to build the future of serverless API development and collaborative coding with all of you!

Our post on Product Hunt skyrocketed to #2 Product of the Day, competing against new products from both Google and Intercom, and the announcement of our $2M fundraise from Stripe was well-received: I appreciate the personalized e-mails many sent in response. It means a lot, and we are very thankful to have such an awesome community of developers and supporters.

With that in mind, it's been six days since Code.xyz went live and we're on a roll — we're rapidly absorbing as much developer feedback as possible. I'd like to use this opportunity to cover our current changelog, establish a cadence for when you can expect product updates to both Code.xyz and StdLib to be announced, and finally, feature some feedback from the community.

Code.xyz Updates

  • Per popular request (thanks, Hugo!) we've improved cursor navigation in Code.xyz:

    • cmd + / (Mac), ctrl + / (Win) toggles // comments on selected lines (if not all commented, adds comments, otherwise removes)
    • cmd + ] (Mac), ctrl + ] (Win), tab on a highlighted selection adds indenting to every selected line
    • cmd + [ (Mac), ctrl + [ (Win), shift + tab on a highlighted selection removes indenting to every selected line
    • cmd + shift + z (Mac), ctrl + shift + z (Win) now acts as undo (joining previously enabled cmd + y / ctrl + y)
    • cmd + L (Mac), ctrl + L (Win) selects the current line (Unsupported in Safari)
    • cmd + c (Mac), ctrl + c (Win) on empty selection highlights and copies entire current line
    • cmd + x (Mac), ctrl + x (Win) on empty selection highlights and cuts entire current line
  • File Uploads are now supported (you can import files from your local filesystem)

    • Simply right click on the TreeView on the left and select "Upload Files..." — try it below!

StdLib Platform Updates

  • We've added a new function definition parameter, keys, which allows you to define function-specific API keys

For example, in functions/doAThing.js

/**
* This is my endpoint function, called "doAThing"
* @keys MY_API_KEY
*/
module.exports = async (context) => {
  // context is a "magic parameter"
  return context.keys.MY_API_KEY; // return API Key
};

You can pass in these keys to a StdLib function in one of two ways programmatically;

1. Using the lib-node Library

const lib = require('lib');
const myUsername = lib.myUsername({MY_API_KEY: 'someValue'});
let result = await myUsername.doAThing();
console.log(result); // returns "someValue"

2. Using an HTTP Request Directly

Simply set X-Authorization-Keys header to value {"MY_API_KEY":"someValue"} (JSON).

X-Authorization-Keys: {"MY_API_KEY":"someValue"}

Product Update Cadence

From this point forward, we will be posting Code.xyz and StdLib Platform updates on a weekly to bi-weekly cadence. We will never go more than two weeks without an update, and you can expect updates on Wednesdays before 9:00AM PT. This is our promise to our community — if there is any reason why Product Updates will take longer than a two week cadence, we will notify everyone ahead of time via our Twitter account, @StdLibHQ.

Community Feedback

We wanted to shine some light on some awesome community feedback we've received on Twitter since launching. If you'd like to be featured here in an update, feel free to tweet at us @StdLibHQ! We may use your feedback to fix a bug and thank you directly, or just include your kind words in a community post!

Chad Fowler (@chadfowler), CTO of Startup Advocacy at Microsoft...

Brian Leroux (@brianleroux), Co-founder at Begin...

Chris Munns (@chrismunns), Senior Serverless Developer Advocate at AWS...

Jared Short (@ShortJared), Director of Innovation at Trek10...

That's All for This Week!

Again, thank you so much for all the positive feedback and kind words! We'll be releasing more information in the coming weeks about the Code.xyz roadmap, our vision as to the future of API development, collaborative coding, and a whole lot more! Also, please keep in mind we're hiring, we'd love for you to consider joining us.

Cheers,

Keith Horwood
Founder and CEO, StdLib

We started StdLib in 2016 with a simple vision: web APIs should be first-class citizens of your development environment. Both developers and service providers should be able to publish, integrate with and manipulate Enterprise-grade APIs with the same ease-of-use they build and share documents or spreadsheets. We built the Standard Library serverless platform and API registry as a first step towards fulfilling this vision.

As it stands, Standard Library combines a scalable compute (hosting) layer with automatically generated documentation, authentication, billing, and more: enabling anybody to turn simple JavaScript functions into production-ready APIs in seconds.

Today, we are thrilled to talk about two major steps forward in our path to achieve the vision we’ve outlined:

  1. We are introducing a new product, Code.xyz, an in-browser code editor — an embeddable development environment for easily building APIs, webhooks, and workflow automation tasks that run atop StdLib infrastructure.

  2. We are humbled to officially announce $2M in strategic funding from Stripe, who many of you know as the payments platform for high-growth startups and technology-forward companies, bringing our funding total to $4M. They join a growing number of API and platform companies supporting us in our mission: Slack is an investor in our seed round, and MessageBird is both a customer and Enterprise partner of StdLib.

Code.xyz

Code.xyz is an online code editor. It was carefully hand-crafted to power API development: specialized for webhooks, workflow automation tasks, and, of course, general API design tooling. You can think of it almost like the Google Docs for API development and publishing — our goal is to (1) significantly reduce repetitive API development work for professional engineers, as well as (2) increasingly provide less technical knowledge workers greater access to writing software and utilizing Enterprise-quality integrations.

Organizations can use the standalone editor on code.xyz to:

  • Quickly design and prototype APIs with complete documentation
  • Share these API design specs internally or with clients
  • Ship these APIs to production using immutable version control
  • Never worry about endpoint scaling: the StdLib cloud auto-scales
  • Manage and share API templates (sources) within your organization or the StdLib community as a whole

Additionally, you can use the editor as an embedded widget in your documentation:

  • Onboard developers to your APIs with shippable, production-ready examples
  • Provide customers the ability to write custom logic in response to webhooks

We’ll be releasing more features around embedding in the coming weeks. The widget you see below is a Code.xyz embed. We’ve pre-loaded it with a simple “hello world” API project. To get started, try simply hitting “Run” in the bottom right to build the function as an API and execute it.

Why Code.xyz?

At StdLib we have been very focused on the future of software development. Mostly, we’ve been ruminating on the question: how will serverless computing change software development? The answer jumped out at us pretty early on: by removing barriers to entry to shipping software, serverless computing allows developers to spend less time worrying about operational implementation of code and spend more time working on integration of pre-existing pieces, or shipping units of integration themselves. Hence, a library of software - a “standard library” of APIs.

We hypothesized that by building a “standard library” layer, and baking in hosting, scaling, documentation, SDK generation, gateway functionality and more as part of the product, the resulting abstraction layer would increasingly allow less technical individuals greater access to building and utilizing web-based compute and provide more technical individuals a rapid development, iteration, and shipping process for APIs.

For the last 18 months, we’ve relied on word-of-mouth and simple command line tooling to enable developers to build with the Standard Library platform. Though we’ve been humbled by the community response to date, after reaching tens of thousands of developers we identified two roadblocks to our continued growth. The first is that for less technical individuals, asking them to install command line tools introduces a pretty high barrier to entry to using our product. The second is that for more technical individuals, there is a lot of noise in the “serverless” computing space and attempting to explain what we provide at StdLib above and beyond a typical serverless platform is less effective than just showing developers through an intuitive, familiar web interface. Code.xyz was engineered from scratch to remove these roadblocks, providing a bespoke experience for our developers and community.

$2M in Financing from Stripe

Around the time we were trying to answer our questions about the future of software development, we managed to find a great connection with the team at Stripe. Stripe’s mission, to grow the GDP of the internet by enabling new business models and lowering the barriers to entrepreneurship, resonated immediately with our own goals. We strongly believe in lowering the barriers-to-entry to both software development and API integration as a means to propel businesses forward.

Today we are humbled to officially announce $2M in strategic financing from a company we deeply respect and admire, bringing our funding total to $4M. The team at Stripe has been amazingly forthcoming and a pleasure to work with. We are especially grateful to Patrick and John Collison for their unbelievable support of our vision — and we'd also like to give a shoutout to Romain Huet, who published a wonderful guide to Stripe Payments with StdLib on GitHub.

We look forward to creating a more open, easily accessible software and API development landscape for everybody. The serverless computing revolution is still in its infancy, with much more to build and create. We eagerly open our arms to new and veteran developers alike. We would be thrilled to have your support.

If you are as excited about the future of software and API development as we are, please do check out our open positions at StdLib.

Thank you for reading and being a part of our journey,

Keith Horwood
Founder and CEO, StdLib