nodeconf / us-cfp Goto Github PK

I'm increasingly interested in progressively enhanced human experiences on the web, something that I think we started losing somewhere along the line. Frameworks like Angular promote dedicated client-side rendering which offers productivity at the cost of performance, accessibility and usability.

Taunus is a framework that puts progressive enhancement first, I think it'd be interesting to have a presentation about it.

Stop Breaking the Web

Taunus

Taunus Source

I think this is an interesting skill to have. A lot of time some API's do things you don't want, behave in a poorly designed manner, or are totally non-existent. Web scraping may not always be the most efficient manner of consuming others' APIs but it is better than not having an API to work with!

Web scraping is easily achieved through the request and cheerio libraries.

I know I've used web scraping to create my own API for services before, I really enjoyed learning how to approach web scraping for this use case and feel that many others in the community would enjoy it too.

Web scraping can be used for more than making your own API out of another service you could use it to run metrics on another person's site to find things such as specific mentions of words or extract all the links and downloaded them (i.e. PDF's).

Reactive Programming has been a hot topic as of late, with Facebook's React, Angular, and Ember on the front end, and libraries such as RxJS, Bacon.js, and Highland. But can we separate the hype from the reality? What exactly is reactive programming? Is it just responding to events in a scalable manner or is there more to it than that? Are there patterns we can learn that help us build responsive applications to load, and ultimately responsive to the user?

I'd love to see a talk covering creating REST APIs with node.js/io.js. Not really talking about any one module or toolset but more a coverage of best practices, common pitfalls and hopefully some production experiences and insight.

I'd love to learn more about hacking on node itself. How does it work.

I'd love to see a talk on what different tools are available for benchmarking and performance analysis of node applications or modules. Perhaps something where DevTools / node inspector / flamecharts / dtrace / memdumps are used to find highly-accessed or slow parts of the application, or parts that eat up lots of memory or create unnecessarily large stacks. For example, this can be used in comparing the overall performance of two different modules accomplishing the same task such as making an API call or processing a high-volume of data.

I would like to see an overall view of all components needed in a server side enterprise architecture based on node. scalability, security, deployment etc. all the real components, hardware and software, needed besides a process running node.

I have been giving talks at conferences over the last few months or so all about using Javascript and Node to make fun visual things, both in the browser and in the physical world. The talks are always very well received with a good track record of having people start doing some code art and thinking about code differently. Here’s an example talk. My coding partner and I have a ton of work using Node to make some very expressive pieces.

We’re in Portland, OR. Locally to you, there’s a great community across the river in SF called Gray Area. They’re generally more about Processing and OpenFrameworks, but there may be some local JS artists that could give a good talk.

I love having the sort of talks that aren’t necessarily driven by live coding or picking up a specific skill you can take back home and integrate into your process the next day. Soft skills and stories and art make for good mixins at tech conferences.

What are the best practices when dealing with a distributed system?

How do you set it up for dev, testing, staging, and production?

How do you ensure redundancy, speed, and availability?

You've been developing in the browser for years (or months. Or weeks!) You know JavaScript. You're excited to jump in writing JavaScript on the server with Node! You do the Nodeschool workshoppers. You read all the blogs. You make a few little web apps with Express or Hapi. So why do you still feel lost when you sit down to work with Node?

What does a developer who knows very little about back-end or systems programming need to know in order to create amazing things with Node? What concepts, responsibilities, and tasks do systems deal with, and how do people use Node to solve back-end problems?

Submitted with encouragement and help from @groundwater. Would love to expand on concrete subjects that would be useful for front-end developers to know.

Reza Akhavan has built a couple of repos around user systems in node using express and hapi. This is one of those problems that we all have likely had to deal with at one time or another, and so it seems fitting for a talk.

Here are the repos: https://github.com/jedireza/frame and https://github.com/jedireza/drywall

Would be interesting. :)

I would like to recommend we invite @dead-horse to speak from Alibaba in Hangzhou China.

I recently spoke at JSConfa China as a last-minute add-on, and @dead-horse was a tremendous support. He helped me adapt my presentation in both language, content, and style to better fit the audience, and he co-presented the difficult parts during my talk.

The node community in China is large and growing. @dead-horse along with other awesome people help run the China mirror of npm, which faces all sorts of interesting challenges related to the firewall.

If anyone has other active node community members from China they would recommend please do so.

Please also be aware that anyone speaking from China will need ~2mo leeway for travel and Visa arrangements.

It would be nice to see some statistics/discussion of what makes a good module.

Now that npm has so many packages sitting around, it would be neat to take a step back and look for patterns in all the data. What features consistently make for good modules (as in fast, and with few errors)? And what makes a module popular?

Are there things we can do better here or patterns that we should be promoting/discouraging?

the current approach to file watching is a bit janky. Cross platform file watching is a difficult beast, especially considering the number of things that are inconsistent across platforms (symlinks, TEMPDIR)

I had a great chat with @othiym23 about why things are designed the way they are in libuv, and I think a talk discussing this topic would be very interesting.

Piggy backing off #24 , I'd like to see more talks around how new/early/non-developers can learn to easily make websites and apps without having to learn the complexities of building a backend. Thus noBackend.

Things like Firebase, Hood.ie, Parse, Deployd, etc. - and my open source project. At JSFest I talked about my crazy metaphysical journey of learning to become a developer, questioning all assumptions. Now, it might be nice to talk about the tools (and their assumptions) that make things easier for newbies.

This is something that I've been asking myself for a rather long time: There's no framework quite like Rails in Node, yet they all seem to embrace different features. I've tried some of them (MEAN, Compound, Geddy, Meteor...) but somehow couldn't decide on one because they all seemed incomplete in comparison to Rails.

I'd love to see what other Node developers think about this issue.

This is an old post (about 5 months ago) and I have loads more knowledge now and do things a bit differently including how we bootstrap ES6. Will write a new post in the next few weeks and share it then:

https://www.airpair.com/javascript/posts/using-es6-harmony-with-nodejs

I am currently working on this for Paypal and is not a completely open source project but would be able to create a demo that can be a more generic one that will be of use to the community as a whole.
Would really love to hear from what other people have done along the lines of monitoring and resilience with node.js apps.

Relevant projects and modules:

• https://github.com/mrjoelkemp/sublime-dependents
• https://github.com/mrjoelkemp/node-dependents
• https://github.com/mrjoelkemp/node-app-root
• https://github.com/mrjoelkemp/node-dependency-tree
• https://github.com/mrjoelkemp/node-precinct

Some talks that I've given on static analysis applications:

• https://skillsmatter.com/skillscasts/5776-using-static-analysis-to-give-build-tools-a-brain
• https://www.youtube.com/watch?v=X7qXPsfJv90

Specifically profiling in operating systems that do not support DTrace.

I love music but I'm not a musician, I've seen some interesting musical projects (for example https://github.com/substack/baudio and https://github.com/substack/code-music-studio by @substack)

It would be interesting to build and hack your own musical instruments.

In the past JSConf Argentina I gave a talk about NodeBots and the NodeBots Community, I showed some music projects built using Node.js and Hardware (preview https://www.youtube.com/watch?v=I4VkZ5H9PE8), this can involve from simple push buttons to create a drum kit to nice rgb led strips as the ones used by @nodebotanist in her awesome nodebots projects.

A preview of some prototypes I've been working on:

Theremin
Gaita with RGB Leds

I would love to see an introductory talk about writing a native module. This talk would be a corollary to #21 (perhaps even back-to-back or dual speaker talk).

When I wrote my first native module, I was kinda lost at first, despite the fact that I know Node.js and C++ well due to all of the JavaSscript/V8 specifics and relative lack of documentation at the conceptual level. Topics I would like to see covered: V8 API concepts (this is how an object is represented in C++, this is how you call a function in JS, etc), using https://github.com/rvagg/nan to write synchronous and asynchronous functions, argument validation, etc.

@apocas has been doing some solid work on nodechecker for a while now and he does have some funny and interesting battle stories of what is to continuously test every single module in npm, which I believe were only shared in our local meetup. Ah, he also created dockerode

Check the project here: http://nodechecker.com/
Github here: https://github.com/apocas

Set of OSS tools that you need to design and build Enterprise-class APIs entirely in Node.js using Swagger specification and deploy them on any Node.js runtime system.

Relevant projects:

Swagger 2.0 Spec: https://github.com/swagger-api/swagger-spec
Online Editor: https://github.com/swagger-api/swagger-editor
Routing and Validation: https://github.com/apigee-127/swagger-tools
CLI, Project scaffolding, OAuth etc: https://github.com/apigee-127/a127

hi,

i think nodeconf is different than any other conf (except taco conf ^-^) lets show it.
so why not just let representatives of each node backend framework do a live code session - against each other.

each framework guy has to solve the same problem in same time.

my backend proposals are:
sailsjs
vaticanjs
feathersjs

problem background:
star wars 7 is close (12 month still)
problem environment:
here is a nice data centric api: http://swapi.co/
problem to solve:
use picture service like flickr, instagram, etc to enrich star wars api with pictures.

when users query for x-wing then a collection of pictures maybe shown nearby available data from swapi.

does it make any sense?

I love code art, creative coding, generative art, whatever the name you apply to it. We have all these tools and all this knowledge as developers, and I love when people use them in unexpected ways or bend them to make something amazing.

Using D3, a data visualization tool, to make generative art. Glitching out images to make something crazy. L-systems to create motion or color patterns.

We all love coding, and many people don't think about creating something expressive rather than functional. We can all be artists if we want to be.

I talk about this stuff a lot (most recently at Nodevember), and would love to do so again. But if not me, someone on this topic would be great, because we could be using the right side of our brain in better conjunction with our left if we try.

Let's make art!

An honest and open discussion of the current status of Joyent/Node and IO.js. Where they are in relation to each other, what the future looks like, and how it impacts the community. Even a Q&A format would be good provided the person presenting was in a position to give the best answers.

We gotta have some NodeBots at NodeConf of course! A couple of possible topics off the top of my head:

• Johnny-Five in the browser via Node-Webkit
• Wearables
• State of NodeBots. There are several startups in the bay area and elsewhere doing some exciting NodeBots work. Lots of new hardware and platforms coming out, and J5 support is growing fast.
• Adding support for new platforms to Johnny-Five using board-io

I find there's not a lot of widespread information on the usefulness of ArrayBuffers and how quickly they perform in V8 + neat uses of them (especially when used with bit operations). I'd love to see some talks about more esoteric uses of JS / node.

I first fell in love with ArrayBuffers when they became a necessity for browser-based work (using webworkers + transferable objects) but since have found myself translating genetic sequences into binary in node for ultra-fast sequence alignment as well as things like storing Brainfuck instructions (translating the instruction set into binary) for playing with genetic algorithms without having to do string manipulation (array accession + bit shifts to read commands, mutating instructions by randomly flipping bits).

I'd like to see @hueniverse talk about debugging node issues.

http://node-machine.org/

I'd love to see a presentation about AWS's new Lambda service:http://aws.amazon.com/lambda/

I am interested on how RealTime Pub/Sub (in particular OMG DDS) can be easily integrated with nodejs. I am working on something similar and I am not a node or javascript expert so I would love to know what the community thinks.

It seems that an increasingly large number of desktop apps I use every day (like Slack, Atom, and others) are backed by Node as bundled up in projects like Atom Shell.

I'm personally working on a hyper-extensible desktop email client that's all React with a Node backend on Atom Shell in Coffeescript. I'd love to see this hybrid world take off more and learn about how people are using this medium.

This talk will discuss various instances where code that should very likely work does not do what is expected. It will have a less technical portion meant to inspire new developers, and help them recognize that sometimes when something doesn't work it might not be your fault. It will also have a more technical portion where we will look into some instances where things just don't work, going specifically into depth of the file watching api in node

There could be a few different approaches to talks on this subject.

This article on isomorphic javascript is an interesting read and would make for an interesting talk.

The article mentions that Meteor.js is one of the largest isomorphic projects. It would be interesting to hear someone from the project speak to that.

Isomorphic javascript and React.js -- Has anyone written something that goes further than the tutorial? That would be fun to see.

I'd like to see and hear a talk on someone building a tool to review all the untrusted JavaScript that many of our developers seem to be pulling into their projects without thought and well... just trusting it. A tool that will raise alarms when known vulnerabilities and possible buggy areas should be manually reviewed.

There's a new specification that addresses part of this issue: http://www.w3.org/TR/SRI/ Firefox and Chrome have initial implementations of this new specification.

Speaker: @arb

Adam has more than a few theories about node/io conspiracies. I would expect this to be a short talk that provides a lot of entertainment value.

I think this is also an interesting topic to heard about it, I have seem some cool desktop applications made using Node.js and node-webkit

https://nodesource.com/blog/node-desktop-applications

Can we please plan to do this properly this year!

/ @floating @dshaw @timoxley

With all the changes to streams like streams3 and simple streams construction in io.js, it would be nice to see a talk about streams.

Things that matter to me:

• How the node community is onboarding new members, especially those underrepresented in tech
• How the node community is supporting new members past the onboarding/pipeline phase
• Where and how the node community gives back to other communities, either in time or resources to charities and nonprofits

I'd like to see a talk that covers the re-invention or re-engineering of something considered "solved" e.g. encryption, table indexing, or in my case file compression. I give this example as the kind of talk I would give on this subject, but I would much rather see it given by someone else who did a similar thing:

Over the course of few weeks, I came up with a great idea for how to compress very large text files.

My basic approach was a binary tree that assigned the shortest possible values to the most common strings, and used a frequency table that was standard across all texts in one language.

In the pursuit I hit pitfalls and took shortcuts that turned out to be ineffective time-sinks, but my final version actually kinda worked!

Now, I also discovered when I was nearly done that I was re-inventing a well known form of compression called Huffman encoding, and existing modules did this better than I could hope to.

However, part of the point was that by building from scratch a system to solve a 'solved' problem (think of other examples in encryption or storage) I gained basic insight into the limitations of each compression method available.

Nightscout is a node app that lets diabetics see their realtime blood sugar remotely http://www.hanselman.com/blog/EnablingWebsocketsForSocketioNodeAppsOnMicrosoftAzure.aspx

Recently it's become very cheap to call into C++ from JS. Though pending that the API is done correctly. I would like to see a talk that covers this stuff. e.g. The fact that every C++ from JS call is implicitly wrapped in a HandleScope, so they're almost never necessary. Or get into the performance cheats between storing flags in external memory that are easily shared between JS and C++. Also how working with object properties in C++ should be pushed back to JS land.

There will probably be a section on https://github.com/rvagg/nan, but I'd like the emphasis to be on how users should feel more confident to get the performance results they're looking for, and not be afraid of writing native modules.

Possibly add a brief primer on how to write applications from scratch that easily allow these types of improvements in the future. W/o needing to work around past cruft.