More info to come.
Today’s Javascript developers are working at an intersection of user experience, security, and the next generation of connected technologies. With the growth of full-stack JS tools and the expansion of the Internet of Things, robust Javascript applications will play an even bigger role in the devices and tools we use every day. With this great power comes an even greater responsibility to our users, and to their privacy. How can we advocate for and build the future of usable and trustworthy security?
This talk will explore findings from user studies I’ve worked on over the past two years focused on developers and security. While I found that generalist JS developers possessed less specialized security knowledge than peers working “closer to the metal”, I also found evidence to suggest a more developed commitment to user advocacy within this group, a crucial factor for improving the end user experience. Moreover, preliminary findings suggest that improving the user experience of security tools for generalist developers can lead to improvements in usability and accessibility for end users.
To conclude, I’ll share design principles and tactical examples for improving the developer experience of security tools, and discuss ways in which JS developers can effectively advocate for (and implement!) usable and trustworthy security solutions.
Heatflask (https://heatflask.herokuapp.com) is a web-application that produces unique cyclic animated data visualizations and encodes them as GIFs on the client. I am going to showcase some of the techniques I use on the front-end to make it work.
It's hard to bring up static types in JavaScript without starting a debate. The benefits of using static types are real, and so are the tradeoffs; the key to figuring out if the benefits outweigh the costs for you & your team. My team recently went through this; I'd like to share some of the lessons we learned, & shed some light on how static types can help your team.
Code is Law, said Larry Lessig. But as our speaker likes to add, Law is Law, too. The rules of cyberspace are shaped both by those who write the code and those who have the power to pass laws and rules.
We understand that as citizens, we're obligated to follow the law. Too often though, our politicians aren't nearly as good at following the technology. If they don't get it, they risk harming what makes the internet awesome. And they won't get it unless they learn from developers and all our technologist citizens.
Chris Riley, head of public policy at Mozilla, will discuss how the future of Internet policy is CATS. Yes cats certainly. But also, Competition, Algorithms, Tracking and Security - all complex issues that will be in political debates for years to come, and issues that demand technical translation if governments around the world have any hope of getting the policies right. His Mozilla peer Diane Tate will help him unpack what this means for engineers in this 40-minute interview (with time for Q&A).
We live in a world with enormous amount of data presented to us and with the advancement of technology and research, we process more information and are empowered to make data-informed decision about many things in our lives. For example, we can get suggestions on the movies we are more likely to enjoy, be reminded by things we have to buy when we enter a grocery store and even avoid traffic congestions and receive fastest route getting from point a to b.
Data Visualization has played a critical role on our ability to consume large sets of data. Even though commonly used chart types such as bar charts and line charts have been effective ways to present data, leading publishers and companies have been exploring better ways to tell stories using data by leveraging the latest technology and research.
Pega has been developing this project because we think building these complex data visualizations is very code-dependent and time-consuming. With tens of thousands of application developers and partners, we needed a flexible yet highly maintainable approach to produce and deploy these visualizations. Writing javascript which has been a primary method to develop these visualizations is not scalable and painful to maintain and troubleshoot. Visual programming method allows Pega to control fundamental building blocks and core architecture while enabling application developers to create data visualizations to meet demand and specifications of many enterprises.
You can find a very early prototype (don't judge us for the UI) of building a simple radar chart. https://www.youtube.com/watch?v=ZBN24SJnp_Q
Agenda 1. State of Business Intelligence - Many BI solutions are focused on helping users to create common chart types faster which is great. - One the other hand, authoring for many advanced visualization still is a challenge because of a steep learning curve. 2. Change of Perception - Chart as an atomic unit of data visualization. - There are only handful of chart types to support. - It is impossible to create advanced visualizations without coding. 3. Opportunity to Change How We Author Data Visualization - We propose visual programming language for web data visualization authoring. - Provide set of fundamental building blocks and enable complex results to emerge from them. - By organizing building blocks, authors can configure complex data visualizations with interactions and animations which is important to effective story telling. 4. Demo - Common chart types with interactions and animations (Bar, Line, Pie, scatter plots) - Advanced data visualizations (Rebuilding NY Times examples) 5. Design Decisions and Challenges - Three.js - Lazy Evaluation - Interactions - Animations - Rendering
Often we find ourselves needing to change or rewrite a legacy chunk of code and face the precarious task of trying to modify the mess without the safety net of regression testing.
This talk covers how to use the features of Jest to spelunk a piece of hairy code, map out its behavior and lock it down with tests before making major changes. By going about it a systematic way we can safely refactor the code while discovering how it works.
Immersive Analytics is an area of emerging research that blends analytical reasoning with immersive virtual spaces to enhance collaborative decision-making.
Through the use of virtual reality, augmented reality and large scale tiled display environments, Immersive Analytics can be used to connect colleagues both synchronously and asynchronously as well as locally and remotely.
Come join the conversation with Todd Margolis who will present a highly interactive discussion that offers analytical examples from a variety of industries, from healthcare, manufacturing, metagenomics and retail, demonstrated by the Qlik analytics platform with Oculus Rift, Microsoft Hololens and tiled-displays through Unity 3D and SAGE2 collaboration middleware.
How to setup Atom to lint JavaScript code with eslint regardless of whether you're writing commonjs, node, react, or for angular 4.
This is the story of how I used Vue.js to build the redesigned UI of our web application. While I was initially skeptical, Vue made it easy to just try it out on a tiny feature at first, eventually building a full featured SPA without much more knowledge required than for the "Hello World" examples that I started with. Along the way, I learned some surprising things by trying a new tool and will share lessons about how framework creators can build tools that allow developers to be productive without sacrificing performance or an enjoyable user experience.
Three years ago, I made a transition from JavaScript to ClojureScript and have not looked back. In this talk I'll explore the costs and benefits of using ClojureScript, a functional lisp, and why you should consider making the same transition.
PUT or PATCH? 200 or 201? HTTP or WebSockets? Today, protocols requiring enormous tribal knowledge rule the web when we really just care about calling remote functions. Introducing GRPC, an RPC framework from Google built on top of HTTP/2 and Protobuf. Define your API as plain old functions and generate idiomatic clients for a variety of platforms. In this talk, we’ll learn how to move faster and break fewer things with GRPC.
"Works for me." The words spoken to dismiss a thousand bugs. "Can't Reproduce." Issue closed. "You're getting worked up over nothing." "It was just a joke." "I worked just as hard to get here." "It didn't bother me." Problem dismissed.
"Works for me" is a natural reaction when confronted with cultural issues that don't impact us directly. It's a statement that isn't inaccurate, but is wildly incomplete. We have to learn to see past our own experiences and see and accept the experiences of others.
This talk will dive into how and why dismissal of culture concerns happens in the tech community, and how we can combat it with knowledge and empathy.
A design system can vastly improve your team's productivity, but most of all, it leads to better products! We're going to explore common approaches to building design systems, the technology behind them, and how to go about creating your own.
In this talk we’ll explore how we replaced a buggy iOS app and an outsourced and abandoned Android app with a single React Native and ClojureScript app.
React Native allowed us to write a single codebase; GraphQL allowed us to eliminate the data-syncing issues that plagued the iOS app; ClojureScript let us move fast and recreate, in a matter of months, what took almost two years to build in Swift and Java.
We’ll discuss the obstacles that we encountered, how we circumvented them, and where we think the mobile industry will move. This is an exciting time to be (or become!) a mobile app developer.
What a tangled web we weave. I don’t follow celebrity couples but it’s hard to ignore the love matrix that is the Kardashian family. With ES6 proxies, you can create behavior akin to pointers. Come listen as I throw shade and we learn about ES6 Proxies. We’ll learn about their behavior, how to use them as pointers, and how to use them to practice tree traversal. JS tree traversal will help you study for interviews, without having to setup a different environment.
We're going to examine how and why to use pure React components to both enable faster development and guard against UI breakage with perceptual diff testing. Too often, a variety of small changes will inadvertently change the display or functionality of a piece of UI - we want to mitigate that. You'll learn about strategies for testing and iterating on UIs more quickly with well-defined dependencies, why redux is perfect a great approach for this, and tools for leveraging perceptual diff (Percy, dpxdt, etc..) as a testing strategy.
Are you interested in TypeScript, but not sure where to start? Like most modern web development, it can feel like there are too many options and no obvious answers.
This talk will share best practices for integrating TypeScript into both Node.js and Webpack+React/JSX workflows, how you can benefit from the features TypeScript offers, and answer common questions about TypeScript.
This presentation focuses on Deep Learning (DL) concepts, such as neural networks, backprop, activation functions, and Convolutional Neural Networks, with a short introduction to D3, and followed by a TypeScript-based code sample that replicates the Tensorflow playground. Basic knowledge of matrices is helpful for this session, which is intended for beginners.
Oswald is a former PhD Candidate (ABD) in Mathematics, an education junkie (6 degrees), and an author of 17 technical books (including Angular). He has worked for Oracle, AAA, and Just Systems of Japan, along with various startups. He has lived/worked in 5 countries on three continents, and in a previous career he worked in South America, Italy, and the French Riviera, and has traveled to 70 countries on six continents. He has worked from C/C++/Java developer to CTO, comfortable in 4 languages, and wants to become fluent in Japanese. Currently he is a consultant and provides training in Android, Deep Learning, and Angular.
Before you bury yourself in packages, learn the NodeJS runtime itself. This talk will challenge the very limits of your NodeJS knowledge.
A new open source library for building visualizations with react. vx is a library of low-level components that could be used to build a library of reusable charts or that special idea you had for a visualization that you’ve never seen done before.
Come spend some quality time with speakers, attendees, and generally great people. Talk about the great talks you saw and relax before tomorrow's big conference day and this weekend's workshops.
Need a ticket to a workshop? It's not too late! Email info@forwardjs.com for a code to register.
When you go to a club or a party or a rave.. What is one of the most obvious things you notice about the music?
It's repetitive!
Since we are engineers, what comes first to mind when we see something repeating itself over and over again?
Automate the damn thing \m/
I've created a Node.js module called Scribbletune which has a very minimalistic API (only 3 methods). I'd like to showcase this module along with the options available to us today when it comes to creating music with JavaScript & Node.js right from the terminal. Using my module and regular JavaScript String and Array functions I will put together the structure of a Electronic Dance Music track and show how easy it is for you to start dabbling with EDM using JavaScript
Some of your users are on mobile browsers that may be more advanced than the desktop browsers of other users, but chances are those phones with their advanced browsers may have similar memory and bandwidth constraints to the computer you threw out or recycled 5 years ago.
While as developers we’re finally enjoying the ubiquity of modern browsers accessing the web, it’s the devices themselves that are now creating constraints we always need to consider. The issue with mobile isn’t “Old IE”, but rather battery life, latency, memory and UI responsiveness. In this session, we’ll discuss best practices to make sure your site performs well, no matter how your user is accessing your content.
React Native is great for writing cross platform apps. Certain use-cases, however, still require native code. Together we will look at how to evaluate when native code is the better choice. I’ll cover strategies for dealing with performance issues and how to handle background tasks like geolocation.
A look at a new family of geometric Lisps called ETNs and one that compiles to Javascript
Static site generators have offered intriguing new options for web developers, but until recently, they lacked a user-friendly interface for content editing—what many would call a CMS. There's now a handful of viable solutions out there, and as they gain traction, it's leading to some interesting confusion about what a CMS means when the architecture isn't all in one monolithic server app. I’ll present some different approaches to the problem, and a view of the landscape in the post-monolithic, serverless world.
Depending on whom you ask, a websocket is either a pipe, a channel, or a protocol. We know they allow two-way communication between a browser and server, but if you don't understand how they work, using them can be a leap of faith. Join us for a deep dive into websockets. We'll start at the browser and see how to connect, inspect and debug. Then we'll use node.js to build a websocket server using TCP sockets. Finally, we'll use a few handy Linux tools to peak into the kernel and see what's going on at the very lowest level. Along the way, we'll give concrete definitions to sometimes vague terms, like "connection" and "listening". Love cool tools? We'll explore several for debugging websockets at every layer of the stack. Whether you're just discovering websockets, or have used them for years, you'll learn something new, and discover that all it takes to use them confidently is a little understanding.
In recent years, the WebGL standard has been adopted in a huge range of desktop and mobile web browsers. This is an exciting opportunity for Javascript programmers to develop 3D applications that can be executed directly in the browser. However, it also presents some unique challenges. In particular, optimizing WebGL-based 3D applications, so their performance provides an interactive user experience, is challenging. This talk will discuss these challenges, and the profiling tools and language features available for the Google Chrome web browser that can overcome them.
Ever try creating an app from scratch with Three.js or pure WebGL? I know I did, and I got nowhere fast. These platforms can be intimidating and tedious for those without an intimate knowledge of computer graphics.
But today, there's a way to build full-fledged WebGL applications and games with a mature editor that professional game developers have been using for about a decade. In 40 minutes, I'll show you how to create a simple physics demo, export it to WebGL and talk back and forth between the WebGL instance and your javascript application. I'll also show you how to customize your WebGL canvas, and how to access remote resources and API's directly from Unity scripting. Finally I'll share some of the advantages and limitations of this approach for production-level development.
To reduce bandwidth usage, an image can be optimized to achieve a smaller file size while maintaining its perceptual visual quality.
Learnings from developing a multiplayer game logic in elm as a finite state machine and exporting it as a npm module that is being used in 1. In mobile(react-native) client to play the game offline and to do optimistic updates when playing online. 2. In server(node) for scoring 3. In web client (react) as a desktop client.
A challenge in real-time collaborative web applications is maintaining consistent state across all participants. In the classroom application we’ve developed at Minerva, this state could involve things such as what document is currently showing on the main stage, whether poll results are visible to students, and chat messages.
Although it’s easy to use a drop-in pubsub solution to deliver messages from one browser to another, it’s much more difficult to maintain an eventual consistency guarantee for all the state that is communicated. Simultaneous and conflicting user actions, unequal network latencies, dropped connections, bogged down CPUs, and participants entering in the middle of a session all complicate matters.
In this talk, I’ll show how we extended Backbone to provide this consistency guarantee without requiring programmers to think about race conditions, all while using speculative updates to maintain a responsive web UI.
To enable screen reader support, press shortcut ⌘+Option+Z. To learn about keyboard shortcuts, press shortcut ⌘slash.
Adding real-time in React is fun. It doesn't have to be complicated. We can make a real time chat in 40 lines or less, using Deepstream and functional programming.
This talk is about loading code during page load time vs lazy loading, then how to load JS modules both synchronously (during page load) and asynchronously (lazy-load) using System.js over Babel, as well as how to used Webpack 2 to bundle your app and resolve dependencies.
What will the audience learn: - The fundamentals on when to load your modules (page load time vs lazy loading) for a most optimized page performance - The 3 main module systems in JavaScript: AMD, CommonJS and ES2015 modules - The ES2015 Module Loader spec and System.js - Importing modules synchronously and asynchronously - Webpack 2 as a dependency management system
Is it better or easier to work on the web today, 20+ years after its creation? What lessons have we learned—and what are we still doing wrong? Max Firtman explains why, after years of adding layers of complexity to the front end, especially in relation to layout, compatibility, and performance issues, it makes sense to go back to the roots of the web and see if we've really evolved from the 90s.
Max also looks to the future of the web, exploring how PWAs, AMP, WebAssembly, and React build on lessons learned from past endeavors, such as Flash, AJAX, WML, and responsive web design.
RxJS has become a popular framework for managing asynchronous tasks and its flagship Observables even being a current ES proposal. You can find many resources on how to use RxJS but very few which explains how it works. I've found that building things from first principles works best for me and would like to show you a barebones implementation of RxJS, enough to have a drag and drop example from its documentation to work. This will highlight the essence of what RxJS is and enable you to think better about how to use it.
GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. I will walk through how to approach adding it to your React and Angular projects and explore the relationship between it and your UI. I will also explore the architecture of Apollo Client, one of the leading GraphQL client implementations.
A look into how transducers are implemented in Javascript, how and when to use them, as well as a fresh take on how they can be improved.
Lush Lounge is located a short walk from the venue. Join us to unwind and chat with fellow attendees, speakers, and organizers.
Lush Lounge does not serve food, so plan accordingly.
*Cash Bar
221 Polk St, San Francisco, CA 94109