crcn's comments

Deep Q & A for friends, family, and strangers. My goal is to create a space where people can get to know each other a bit more deeply and spark conversations. Would love some feedback!

App: https://hey.shaya.so/ Website: https://www.shaya.so/

Ideally you'd use Tandem along-side your text editor. It's not meant to replace writing code - I think in most cases it's easier to write code by hand than use a visual tools. Though, I think there are cases where it's easier to use visual tools against a live application preview for making small adjustments - that's where Tandem fits in.

Here's a better video demo to help demonstrate this:

https://www.dropbox.com/s/pc50x5m991j71ot/html-css-js-demo.m...

Thanks for the feedback! I figured that short videos throughout the website would be enough to describe visually what Tandem is, but a short video at the top would probably be better.

And yeah, there are a ton of UI design tools out there on the web, it's been my #1 concern when building this thing out because they all promise similar tooling. Though, I'm trying to position this app as more of an Atom, or VSCode-like since it's geared to be another kind of extensible development environment. I figured that open sourcing it would be a first good step for that since developers would probably need to understand the internals before writing plugins for new UI tools, code writers, etc.

I went ahead and added a "Fork me on GitHub" badge to make it more clear that this is open source.

Sorry for the confusion there, I went ahead and clarified the descriptions.

Tandem runs any application, but needs the appropriate extensions in order to write code. It has the capabilities of writing PHP, but that isn't implemented yet.

The code writing aspect of Tandem is really just a small feature of the whole application - The focus of Tandem is really to provide a preview (or many previews) of your application with tooling that makes it easier to fix visual bugs.

Yep, I made Tandem open source here: https://github.com/tandemcode/tandem

It is a bit like WebFlow, but focused more-so on the coding aspect. Tandem integrates with your text editor, encourages you to write code instead of using the design tools to all of your UI work -- they're mostly there for UI adjustments, and to create features that are hard to code by hand.

Thanks for the heads up - the todos example should be fixed. Right now the todos example is pretty simple - it just hooks up with a socket.io (master) server which re-broadcasts all operations to each connected client.

Shouldn't be too difficult to implement. Here's one possible way to do it:

https://gist.github.com/crcn/cac5b5826590abed921d

I'm a front-end developer, and there's lots of service features to think about when building a single page app:

Should app data be generated from the server initially? Should the app support offline read-only mode? Should the app support realtime data? Should operations be batched and sent to a data source? Should the app be isomorphic?

And others. I built crudlet to help encapsulate services so that these sorta features can be added anytime without affecting the rest of the application.

That, and also to help decouple applications from a particular service. For instance, it'd be pretty easy to swap firebase with parse, or socket.io for pubnub if you want.

They definitely solve similar problems. Bigger difference is that crudlet acts more like a utility belt library for interacting with service adapters that support the same operations. You can really do just about anything you want. For example, here's crudlet used as an event bus system:

https://gist.github.com/crcn/cfe215ab3b604fb0b441

Crudlet also uses node streams instead of promises.

Author here - the primary motivation behind this library was to make APIs interoperable with other data stores. For example: https://gist.github.com/crcn/be352008bca201e8ac00

Currently working on more examples - didn't realize this would appear on HN so quickly!

Author here - paperclip is pretty stable at this point. The library has been in production for about 2 years now at ClassDojo, and has been battle-tested against all major browsers including IE8+.

The unsophisticated user won't read "related post" because it isn't noticeable. There's no clear differentiation between a recycled "like" post, and one that you physically like. They look almost identical.

I tried to be as genuine as possible. My wording revolved around unsophisticated individuals who makeup a majority of Facebook. "Impersonation" perhaps isn't the proper word to use, but it certainly encompasses the general concern about promoted content.

To the eyes of an unsophisticated friend, I like penis waffles. For the record, I don't. I never liked anything similar, but Facebook re-posted a "like" (VICE) under my name, and attached a related article to attract more people (Penis Waffles).

Facebook doesn't make it clear that promoted content posted under your name is advertisement. On top of that, advertisements posted under your name is hidden from you, and visible only to your friends.

Node.js isn't picking up a new paradigm. The issue is very present in JavaScript, and it's easy to write spaghetti code since the language by itself doesn't offer much structure. It's possible to write very clean JavaScript / Node.js code, but it takes a different approach over how you design / develop apps versus a class-based language.

This was my first thought. Languages require different design principles. If you're calling JavaScript "spaghetti code", then you're doing it wrong.

Thanks for the feedback. I'll add a few use-cases / examples to the project page.

Here are a few good examples which use sift:

- Realtime API library: https://github.com/crcn/guava

- Simple database written in node.js: https://github.com/crcn/gumbo. I use this primarily in command line utilities, and other applications where mongodb seems a bit over the top.

Underscore is certainly a better alternative in many cases, but the goal for sift is to provide control over filtering collections with one query versus manipulating them.