We live in times driven by perpetual innovation, shaping how we live and impacting our social behaviors. As we improve the tools we use to make the world a better place, we do it at an outstandingly fast pace. But we’re still only human; can our integrity and sanity keep up?
It comes down to adjusting our soft skills. Which ones are key in a fast-paced front-end environment? How do we develop them so that everyone can benefit from the work we do as coders and community members? What’s required of us to become a professional front-end developer, as well as a decent human in the technology race?
Through my research with children, games and learning (all of which I’ve worked with over a number of years) I have found that the way kids use interfaces differ a lot from adult interaction patterns. They have different search patterns, language skills, cognitive skills and motor skills. And this has a big impact on the way we should design interfaces when the users are children.
This subject is important, because kids these days use online tools from before they can read. They are growing up in a new paradigm – they have not known the world before the Internet. This impacts the way they act on, interact with, and perceive, the web.
In this talk, I will inform you about the way kids interact with interfaces, how it differs from the interaction patterns of adults, and provide you with some guidelines on how to design (non-game) web interfaces for kids.
In an ideal scenario, when you’re going to convert a non-responsive site into a responsive one, you start from scratch and do everything right and perfectly from the beginning. But where’s the challenge in that? In reality, starting from scratch is just not practical or possible for many projects, so what can we do to overcome some of the most common obstacles and still get to that elusive, mobile-first, responsive site?
In this talk, I’ll go behind the scenes through the nitty-gritty of a real world responsive retrofitting project, and give handy tips that can be put in practice by other teams facing similar challenges.
OMG, this local-freak will talk about web gaming again. WHYY? I don’t want to attend another HTML5 gaming talk!!!! C’mon dude, we all know that it’s possible to make a game in web technologies that run on mobile phone, fridge, printer, gaming console and etc. JUST STAHP! AGAIN? JS games are soooo 2011!
It’s never on the top of the list for any project I’ve ever worked on, but over the years I have come to realise just how important A11Y is for the web.
From something as simple as Keyboard navigation, to enabling those who use other aids to browse the web, we need to make sure we know what we’re doing. I’ll talk about what tools we can use to help us be better accessibility-enablers and make sure that everyone can have a good experience with the sites we build.
Traditionally browsers talk to servers, but what if they could speak to each other? WebRTC is a small set of APIs that make peer to peer communication possible between browsers. Video, audio and data can flow from browser to browser opening up a new set of possibilities for the web.
We’ll take a look at what WebRTC gives you and, importantly, what it leaves out. We’ll cover implementing a simple chat application and speculate over more complicated use cases and examples. I’ll also demo new real-time video infrastructure based on WebRTC.
With the rise of modular web and CSS frameworks, having well structured UI documentation is a must. You probably have already heard about Living Style Guides for the web and CSS documentation, but what lays beyond simple pattern libraries?
Style Guide Platform is the next big thing for building and collaborating on maintainable component libraries. Following Style Guide driven development evolution, we are able to combine various tools for testing, communication and living documentation support in nice, consistent environment.
Let’s explore the possibilities of next-gen UI development and management approach, following the broad experience of world-class teams and Front-end centric companies.
The world of a front-end developer has never been more complex. The rate at which new libraries, devices, protocols, and even languages are appearing can be dizzying. Meanwhile, the capabilities of the platform are exploding, and so are our expectations. Our tools can barely keep up, and we can barely keep up with them.
If it’s hard for us, imagine what it’s like for someone new to all this. For us, the days of throwing a HTML, CSS and JS file in a directory are long gone, but that’s still usually where we tell people to start. That is the web of a generation ago, and we forget how hostile it was. Our tools, while impenetrably complex to a newcomer, make the web a happier place to work.
What if the tools we used weren’t so impenetrable though? What if people, regardless of experience, could build the web like we do?
A fractal is a natural phenomenon or a mathematical set that exhibits a repeating pattern that displays at every scale. In his talk, Gregor will show how he found love for fractals and started making them in CSS or Sass. You can expect to see a step-by-step guide to creating CSS fractals and experiments from simple to complex.
Then he will explain how to connect these fractals to the webAudio API and create optical effects that are generated by music. All in all you will see some amazing structures and visuals. Sit tight some of these experiments might make you think there was something funny in that last drink.
But we can assure you, it’s pure CSS. If you are into visuals and talks with a lot of action and live examples this is the perfect talk for you.
I’ve been there, but I’m a survivor because I learned the art of refactoring. This talk is a guide about how to deal with feature requests and deadlines, all while improving the maintainability of your code.
In this talk, we’ll delve into the purpose behind the sites and applications we make, how we learn and connect as humans, and how we should design our sites and applications with those things in mind – through the world of animation. We’ll cover why we need to use animations, the principles of how to do them right, and both the good and bad examples out there in the wild.
Do you miss the times when Front-End devs were called Web MASTERS? When you did not have to wait for ages for someone else to design a simple form? When there was nobody stalking you to move a button 2px to the left? When there was no philosophy behind the placement of a search field?
Anyway… these days are gone, baby. UX is here to stay, at least for some time, so let’s figure out ways to work together. In the end we all want to make things we are proud of.
We’ll learn what you can actually request from your UX team (guess what, it’s not just prototypes!), when to speak up and how to communicate with UX folks to be effective.
End of Day 2
Centrum Zarządzania Światem
Bring your conference badge! We’ll have drinks and snacks for you.
Please note that Front-Trends party is organized exclusively for attendees, speakers, sponsors and staff.
WebGL is normally associated with 3D graphics, which can seem daunting without a background in this field. However, the WebGL API is inherently 2D, merely supplying a very useful toolbox of functionality for creating 3D engines.
In this talk, we’ll explore how WebGL can be used to manipulate 2D graphics, by creating a simple image editing application. Through live-coding, we’ll see that working with WebGL isn’t all that complicated and can be achieved without having to reach for higher level frameworks, and how hardware accelerated image effects like color changes, deformations or blurs can be implemented in a few lines of code.
Understanding accessibility mechanics is the key to good interface design. Using ARIA to manipulate the browser’s accessibility tree means you can create interfaces in HTML, SVG and even Web Components that are accessible to assistive technologies, without compromising on functionality or design.
While working on my WebRTC enabled side project, I noticed that many asynchronous processes which can be easily explained are really tough to implement using traditional imperative programming with object structuring. Intuitively we understand what it means. It means that we need to define new abstractions to effectively deal with asynchrony.
Increasingly we are seeing the trend of hooking up sensors and electronics to the Internet. As sensors and hardware platforms become more available for hobbyists, web developers can also have fun with the real world by triggering and sensing.
In this talk, we will cover how we can utilise the plenty of sensors already embedded in our mobile phones, to different wireless protocols such as the WiFi or Bluetooth Low Energy as well as some low power devices. Then we will hook them up to a display or trigger them with various web technologies right in our browser.
Automatic tools can spit out super large scripts these days. Look at emscripten for examples, a script of several megabytes is not an exception (more like the rule). How do you process a script that is several megabytes large? Most parsers tend to want to parse everything in one sitting. These parsers run out of memory at some point. How can you do analysis or modifications to arbitrary scripts if you can’t even parse them? Enter a streaming parser. It is capable of parsing a script left to right without retaining more memory in the process. It can yield at any point where it needs more input and it can stream parsed tokens when one is available.
In a world of ever-increasing complexity in compilers, build systems, tests and tools that all have to integrate with each other, it seems that developers have lost their intuition of what is simple. Getting into web development has never had a steeper learning curve and nobody seems to be addressing the fact that this might hurt our community in the long run by scaring newcomers.
In this talk, I will focus on precompilers and transpilers and the workflow and tooling around them. I want to bring us closer to a more comprehensible abstraction and a simpler API that will let the current and future generations of web developers focus on the work, rather than the tools.
To many, “semantic mark-up” means using appropriate HTML elements, not just divs (which should be a matter of course). But there’s more to it…
This talk provides an insight into Semantic Web technologies and how they can be used with HTML: microformats, microdata, RDFa, Schema.org. We’ll cover how applications can benefit from it and its impact on user experience.
What do Klingons have to do with it? You’ll find out…