asprouse

Andrew from TakeShape here! The primary author of this library. We tired a number of different form libraries before settling on writing our own. You can check out a full talk I gave on ShapeForm (https://www.youtube.com/watch?v=iplY8Le1zK0) or you can just read my slides (https://shape-form-talk.netlify.com/) from the talk.

ShapeForm has several nice features that make it perfect for our use case, and may yours:

JSON Schema validation - Easily share the same form validation frontend and backend

️ Fast - Pure components for fast rendering even with large forms

Redux / Standalone state management - Choose your own adventure

Custom widgets - Widgets are simply React components

Form reducers - Useful for async validation, data normalization, the sky's the limit.

If you find ShapeForm useful or want to make it more useful I'd love for you to contribute to the project!

What is a high level example of why I'd use this?

This is why TakeShape also provides a built-in static site generator[0] using Nunjucks templating (think Django, Twig, Swig, etc). If you are trying to build a simple site this is a great option. The great part of a Headless CMS is that you can choose whatever frontend you want and your solution can evolve with your product.

(Full disclosure I'm a Co-Founder of TakeShape)

[0] https://www.takeshape.io/docs/quickstart/

Fixed! Thanks for bringing this to our attention.

abstinence is the best form of cyber-security

Seriously though, you should read "Lost and Founder"[0] by Rand Fishkin of Moz for some insight on what's in store. VC's expect very high multiples on their return 10x is not even close, even small seed funds look for 40x+. That said I am not totally convinced of either model something like TinySeed[1] looks like a step in the right direction. At the end of the day it's about the fit for your business you're not going to escape burnout based on how you are funded.

[0] https://www.goodreads.com/book/show/35957156-lost-and-founde... [1] https://tinyseedfund.com

What happens when the honeymoon phase with your VC backers is over?

The sixers are to blame for these missteps!

Very cool. I have a bunch of code to parse the info param in various projects. Glad you took the time to publish it as a library.

Odd that they hide their FAQ in the shop page and hidden below the fold on a 13" screen. I looked everywhere but there. You'd think you most customers would want their questions answered before buying.

What happens when there is a power or ISP outage?

Isn't this just an iPhone SE?

Sixers unite!

CO https://github.com/tj/co in popularized this technique a few years ago. It implements something similar to the function you present here. Babel actually transforms async/await to generators (https://babeljs.io/docs/en/babel-plugin-transform-async-to-g...) when targeting environments that don't have native async/await support.

How did you decide when it was time to stop bootstrapping and raise a round? Was there a magic number traction-wise (total users, MRR, etc) or was it motivated by the desire to staff up a team and execute on your product vision?

There is a static renaissance happening as people realize it doesn't make sense to serve content that rarely changes from a database. Think of the millions of Wordpress blogs that could benefit from the speed, reliability and security of a static frontend. Here is more in-depth argument for static:

https://www.takeshape.io/articles/why-the-best-websites-are-...

Also check out https://jamstack.org/ for more info on tools and techniques for going static.

I'll be honest it takes a bit of prodding at first and it's hard to do after the fact. I have found that it helps to ask for input from day one. For example if a user is setting up a dev environment for the first time set them up with your setup doc and tell them to take notes about any issues they have or things that should be clarified. The biggest incentive is knowing that your organization values employee feedback and will be receptive to changes they suggest.

*enterprise

Never underestimate the value of engineer training. Document your best practices and coding style. Diagram your software at a high level to show how different components interact. If you have any internally developed frameworks add documentation or at least an FAQ explaining why certain design decisions were made and examples of how to complete common tasks with the frameworks. It might sound like a big investment up-front but it doesn't have to be, start small and your materials will grow with your organization. Encourage your engineers to contribute if they had to figure things out on their own. Being able to point to these materials will help on-boarding and free up your time for high level tasks.

Back in 2003 my fundamentals of CS course heavily relied on the interactions window of DrScheme (now DrRacket https://racket-lang.org/). It was a extremely powerful educational tool. When I started doing web development I found myself frequently putting snippets like `javascript:alert('abc'.substr(1)` into the URL bar. With the advent of the Firebug console it became even easier to try out new snippets. Now a days the Chrome console tab even has autocomplete. I'd be interested to know how these simple interactions contributed to the widespread adoption of JS and other languages.

I find that while coding I practice lazing naming where I am able to start writing `function foo` and which allows me to bypass the upfront naming deliberation. Once I have my code written I can assign an accurate name to function and if the name is too long or convoluted I consider revising the code. So naming for me ends up being a useful tool for self-reviewing my code.

Here's a visualization http://mochimachine.org/wasteland/#

Does the Node.js SDK support U2F?

Check out our quickstart https://www.takeshape.io/docs/quickstart/. It has step-by-step directions to get you up and running nothing with our "Shape Books" sample project. The same steps can be repeated for any of our sample projects https://github.com/takeshape/takeshape-samples. If you are coming from wordpress and looking to build a blog I would check out the shape-blog sample project.

Also I would recommend using Netlify for hosting of static sites. We have a super easy integration with them https://www.takeshape.io/docs/configuring-netlify/

At Newsweek/The Daily Beast we used Adobe AEM which was very powerful. It had a flexible JCR-based content model and component based content editor. At the time (5 years ago) it had very little in the way of a content API so we had to build our own solution. We actually used our Content API with Rhino (Java js runtime) to render DustJS templates server-side. This server side rendering we built there inspired aspects of our Static Site Generator. Being able to load a project's GraphQL schema in memory allows us to improve caching when generating a large site.

The content modeling an initial interface was heavily inspired by a CMS we used in our agency work called Webhook (http://www.webhook.com/). It was the first product we found which combined flexible content modeling with Static Site Generation. TakeShape goes one step further to provide a robust API that can be used with by the static site to enable dynamic experiences (think search, tag pages, user generated content).

As far as GraphQL we use Facebook's reference implementation (https://github.com/graphql/graphql-js). The challenge with TakeShape is that we allow users to define their own content types which in turn generates their own GraphQL schema. This makes using high-level server libraries like Apollo which assume a static schema challenging to use. GraphQL itself takes care of a lot of the content functionality on its own. The challenge was adding all the missing pieces like authorization, authentication, rate-limiting, access policies, data validation, etc.

Andrew here the other Co-Founder

We excited to share the tech TakeShape with you. The backend is mostly server-less using Serverless Framework, AWS Lambda + API Gateway. For our data layer we use DynamoDB as our system of record and ElasticSearch for advanced search functionality. The frontend is built with GraphQL, React, Redux, Redux Saga.

I am working on some write-ups on how we built certain features on the TakeShape blog. In the meantime feel free to post technical questions here and I'll try my best to answer in a timely manner.