balabit / coderegation Goto Github PK

speaker: Carina C. Zona
topic: Consequences of an Insightful Algorithm
video: https://www.youtube.com/watch?v=znwWYR1mzzw
length: 30 minutes

We have ethical responsibilities when coding. We’re able to extract remarkably precise intuitions about an individual. But do we have a right to know what they didn’t consent to share, even when they willingly shared the data that leads us there? A major retailer’s data-driven marketing accidentally revealed to a teen’s family that she was pregnant. Eek.

What are our obligations to people who did not expect themselves to be so intimately known without sharing directly? How do we mitigate against unintended outcomes? For instance, an activity tracker carelessly revealed users’ sexual activity data to search engines. A social network’s algorithm accidentally triggered painful memories for grieving families who’d recently experienced death of their child and other loved ones.

We design software for humans. Balancing human needs and business specs can be tough. It’s crucial that we learn how to build in systematic empathy.

This presentation is from JSConf EU 2015.

speaker: Adnan Alturkistani
topic: Lean Principals in Project Management within Technology Projects
video: https://skillsmatter.com/skillscasts/6480-lean-principals-in-project-management-within-technology-projects

Lean has become an almost staple way of thinking for new and next generation technology projects. But how in reality does it work with IT based projects?

The goal of Lean Thinking, at least to my mind, has always been to deliver a continuous stream of value into or on behalf of an organisation, with as little waste as possible, in the shortest possible timeframe.

This way of thinking is closely aligned with our goals as PMs. That is to say we want to compete our projects on time, on budget, and to agreed quality. So it comes as no surprise that the marriage of Lean principals and project management looks like a match made in heaven.

This session will be divided into two parts; the first part is a 15 minute presentation with an introduction to Lean Principals and its benefits to IT projects. The presentation will cover the lifecycle of an IT system implementation project.

The second part will be interactive where a Leanness Assessment Tool will be discussed within the groups.

speaker: James Powell
topic: Generators Will Free Your Mind
video: https://www.youtube.com/watch?v=RdhoN4VVqq8

What are generators and coroutines in Python? What additional conceptualisations do they offer, and how can we use them to better model problems? This is a talk I've given at PyCon Canada, PyData Boston, and PyTexas. It's an intermediate-level talk around the core concept of generators with a lot of examples of not only neat things you can do with generators but also new ways to model and conceptualise problems.

speaker: Merklik László
topic: Fejlesztés Nagyban
video: https://www.youtube.com/watch?v=eEHmsn-pCJM
length: 34 min

Az Empire State Building rengeteg szempontból egyedülálló, majdnem 100 évvel ezelőtt 1 év alatt megtervezték és megépítették az akkor legmagasabb épületet Manhattan szívében. Kevesen tudják azonban, hogy az építésénél az egyik legnagyobb kihívás az volt, hogyan lehet olyan rövid idő alatt olyan sok anyagot odaszállítani a belvárosba. A teherautók éjjel-nappal mentek oda-vissza 1 éven át. A nagybani szoftverfejlesztés is ehhez hasonló, itt a szűk keresztmetszet a fejlesztő. Sok mindenről lehet beszélni, de a nap végén, ha nem tudod elérni, hogy rengeteg ember együtt dolgozzon ugyanazon a szoftveren, akkor nem fogsz semmi szignifikánsat építeni.

It was at Craft Meetup September 30 2015.

speaker: Herb Sutter
topic: Modern C++ - What You Need to Know
video: https://www.youtube.com/watch?v=TJHgp1ugKGM

This talk will give an update on recent progress and near-future directions for C++, both at Microsoft and across the industry. This is a great introduction to the current state of the language, including a glimpse into the future of general purpose, performance-intensive, power-friendly, powerful native programming.

speaker: Martin Fowler
topic: Microservices
video: https://www.youtube.com/watch?v=wgdBVIX9ifA

In the last decade or so we've seen a number of new ideas added to the mix to help us effectively design our software. Patterns help us capture the solutions and rationale for using them. Refactoring allows us to alter the design of a system after the code is written. Agile methods, in particular Extreme Programming, give us a highly iterative and evolutionary approach which is particularly well suited to changing requirements and environments. Martin Fowler has been a leading voice in these techniques and will give a suite of short talks featuring various aspects about his recent thinking about how these and other developments affect our software development.

speaker: Pascal Precht
topic: Dependency Injection for Future Generations
video: https://www.youtube.com/watch?v=8c-qv9TisVE

Because dependency injection is cool and that it makes life of all us developers a looot easier, we start off this talk by first understanding what dependency injection stands for and why it is such a blessing in disguise...and also because first things first. Once that is clear we can dive deeper into some existing implementations, to get a real feel of how it all works, and finish by looking at how these implementations are used inside the new Angular 2, by embracing the power of TypeScript annotations.

speaker: Philip Roberts
topic: What the heck is the event loop anyway
video: https://www.youtube.com/watch?v=8aGhZQkoFbQ

We say things like “don’t block the event loop”, “make sure your code runs at 60 frames-per-second”, “well of course, it won’t work, that function is an asynchronous callback!”

If you’re anything like me, you nod and agree, as if it’s all obvious, even though you don’t actually know what the words mean; and yet, finding good explanations of how JavaScript actually works isn’t all that easy, so let’s learn!

With some handy visualisations, and fun hacks, let’s get an intuitive understanding of what happens when JavaScript runs.

speaker: Ördög Rafael
topic: Tanuljunk meg esni
video: https://www.youtube.com/watch?v=tK_99x7-z6w
length: 53 min

A mikroszolgáltatás-orientált architektúra jó dolog, de megvannak a maga kihívásai. Ördög Rafael, aka DeVill "Esni is tudni kell" c. előadásában arra keresi a választ, hogyan lehet felkészülni a szolgáltatások közötti kommunikáció során fellépő problémákra. Amíg minden egy gépen fut egy processzben, addig természetesnek vesszük, hogy az összes utasítás végrehajtódik. A mikroszolgáltatásoknál viszont fel kell készülni, hogy nagyot lehet esni. DeVill arról fog mesélni, hogyan írjunk olyan robusztus kódot, ami garantálja, hogy egy-egy botlás után karcolás nélkül és azonnal tudjunk talpra állni.

speaker: Golden Krishna
topic: The Best Interface is No Interface
video: https://www.youtube.com/watch?v=w0AdsVReXi8
length: 38 min

Many believe the future of design is in screens. They're wrong. Our love for the digital interface is out of control. This conversation, led by Golden Krishna, will explore a better path: NoUI. Eliminating counterintuitive input mechanisms for natural inputs inverts the contemporary focus of software design to have computers adapt for people, rather than people adapt for computers. The results can have a profound impact on your design process and our lives.

topic: Functional C++
speaker: Kevlin Henney
video: https://vimeo.com/131640207
length: 66 min

Functional C++? As opposed to what - dysfunctional? Well, kind of, yeah. Sure, in C++ the principal unit of composition is called a function, but that doesn't mean it's a functional language. And the idea of restricting mutability of state gets a nod with const, but it's a nod not a hug. And the STL shows influences of functional programming, although it falls short of being compositional. And, yes, sure, C++11 has lambdas, but then again, these days, who doesn't? Lambda calculus was invented in the 1930s.

This talk looks at how to express functional programming ideas in (post)modern C++ in a way that can be considered idiomatic to C++, rather than trying to use the power of overloading and metaprogramming to pretend C++ is Haskell or Lisp. In short, immutability beyond const and into shared and persistent data structures, concurrency beyond threading and locks, and thinking about functions as transformations and units of composition rather than actions.

speaker: Jafar Husain
topic: The Evolution of JavaScript
video: https://www.youtube.com/watch?v=DqMFX91ToLw

Jafar Husain discusses interesting features that can be used today in ES6/7, such as Object.observe, async functions and async generators, while also giving a peek at what's being explored for ES7 to make async programming easier.

speaker: Kevlin Henney
topic: FizzBuzz Trek
video: https://vimeo.com/144335290
length: 51 min

FizzBuzz. It's a drinking game. It's an educational game to teach kids division. It's an interview question. It's a coding kata. It's all these things. And it can be fun. It can also be used to illustrate different coding paradigms, languages and techniques, from the serious to the jocoserious to the you-cannot-be-serious. This talk uses this simple problem to take you on a bazaar and bizarre trek, from plain examples to provocative examples in common and less common languages, sequential to concurrent, procedural to functional, elegant to ridiculous.

topic: Introduction to Testing Node.js
speaker: Jordan Kasper
video: https://www.youtube.com/watch?v=u2XCdkL4bWI
length: 30 min

It is a begginer video of nodjs unit testing, but really good base to write good unit tests.

speaker: Julian Cheal
topic: Dancing with Robots
video: https://www.youtube.com/watch?v=zsJnsRGh8dE

Web apps are great and everything, but imagine using JS to fly drones and make them dance to the sounds of dubstep! Or to control disco lights and other robots! Sounds fun, right? In this talk, we will not only explore how we can write code to make this possible, but it will also be full of exciting, interactive (and possibly dangerous ;) ) demos!

speaker: Harald Massa
topic: Becoming a better programmer
video: http://pyvideo.org/video/1324/becoming-a-better-programmer

So you have selected the best possible programming language; you learned about object oriented design, functional paradigmas, test driven development and the Structure and interpretation of computer programs. What else can you do? Harald did research and experimented outside computer sciences. What methods and substances are available to tune your brain for programming? This talk will describe personal experiences with various motivational, self discipline, learning and information management techniques; substances and exercises to tune your brains operating system. There will be expeditions into results from brain research. A critical judgement, pointing out snake oil and stuff that worked.

speaker: Péter Szabó
topic: Method restrictions (abstract, final, @override etc.) and implementing them for Python
video: http://pyvideo.org/video/1314/method-restrictions-abstract-final-override-e

The earlier a bug is discovered, the cheaper it is to fix it. Method restrictions (such as abstract, final and @Override) help the programmer in discovering incompatibilities between a class and its subclass early (i.e. at startup time for Python and at compile time for compiled languages). Python doesn’t provide method restrictions out of the box. To implement them, we take a deep dive to the realms of Python metaprogramming (decorators, metaclasses, method wrappers, traceback inspection and builtins). Lots of short and code examples will be provided to show the building blocks and how we combine them.

topic: Functional Principles for object oriented development
speaker: Jessica Kerr
video: https://www.youtube.com/watch?v=cpyrTkzXeL8
length: 62 min

Jessica Kerr explains through Java and C# code samples six principles of the functional programming style.

date: 2016-03-23
speaker: Guido van Rossum
topic: Type Hints in Python
video: https://www.youtube.com/watch?v=2wDvzy6Hgxg
issue: 12

Guido van Rossum talks about type hints in Python 3.

• PEP 3107
• PEP 0484

Big data solutions involve many technologies working together. Whether it’s collection, analysis, or action, all of those components must be configured, their relationships defined, and deployed. In today’s dynamic data environment, the deployment is bound to change, need to be updated, or replicated. You need an infrastructure and tool set that keep your focus on the data. Flexibility in big data infrastructure automation, and examples of use cases are discussed in detail in this webinar.

This is a webinar!

Live broadcast: 21. Oct. 18:00 - 19:00 CET

Click here to attend: http://www.brighttalk.com/webcast/6793/175487

speaker: Martin Fowler
topic: Workflows of Refactoring
video: https://www.youtube.com/watch?v=vqEg37e4Mkw

Over the last decade or so, Refactoring has become a widely used technique to keep a high internal quality for a codebase. However most teams don't make enough use of refactoring because they aren't aware of the various workflows in which you can use it. In this keynote talk from OOP 2014 in Munich, Martin Fowler explores some of these workflows: such as Litter-Pickup Refactoring, Comprehension Refactoring, and Preparatory Refactoring. Martin also reminds people why common justifications for refactoring will sabotage your best efforts. (This talk also has a treatment as an infodeck.)

More information about Martin Fowler
More information about OOP Conference

speaker: K Lars Lohn
topic: The Well Tempered API
video: https://air.mozilla.org/the-well-tempered-api-2/

Centuries ago, a revolution in music enabled compositions to still be playable hundreds of years later. With compromises in tuning, a universal musician's API became possible: the piano keyboard.

In the world of software, we have business logic, implementations, and abstractions. The more loosely we couple these, the more flexible, resilient and long lasting our software becomes. However, it's not an easy task: our tools and inclinations don't lead us the right way. Just as in music, it may take a step away from purity for software to achieve the highest level of resiliency.

This multimedia presentation uses code examples in Python from Socorro, the Mozilla Firefox Crash Reporting System. This reveals some enlightening parallels between API abstractions and centuries old music. Employing abstractions that are slightly "out of tune", Socorro scales and flexes with remarkable ease.

And, by the way, this is likely the only technical presentation you've ever encountered that features live music on an electric bassoon...

speaker: Ryan Roemer
topic: CascadiaJS 2014 Making JavaScript Tests Fast, Easy, and Friendly
video: https://www.youtube.com/watch?v=BK3dQUjwo9Q

In modern web development, it's more or less a given that writing and running tests speeds development, ensures application robustness, and is most emphatically what you should be doing. And yet, many development teams struggle to get most, or even some, of their JavaScript code bases tested.

It's time to look beyond the standard "how to wire up a test framework" topics and focus on a singular, overarching goal: "how do we get developers to actually write the tests?"

In this talk, I'll discuss the testing lessons learned through managing test infrastructures / education for JavaScript teams of all sizes and writing my book, "Backbone.js Testing". Some key points that have arisen across projects of various sizes and developers with very different backgrounds include:

• The tests must be easy to write.
• The tests must run very quickly.
• The tests must be reliable.
• Developers must be well-supported when they need help in learning testing concepts and as they hit more advanced testing scenarios.
• ... and ideally all of this is in place at the start of the project (or ASAP otherwise).

My presentation will discuss the various means of getting your test infrastructure in shape to make the tests easy to run, write, and rely upon. We'll briefly survey scenarios like frontend JavaScript vs. backend Node.js, as well as the popular test frameworks for both.

I will also talk about developer education and support, particularly for those who have never written a single test before. And I'll discuss getting traction for testing in business organizations (startups or large companies), even under tight deadlines and managers that don't see the immediate benefits of testing.

Finally, I'll offer some practical tips of how you can make testing easier, faster, and friendlier in your development team and spread the testing love!

speaker: Daniel J. Bernstein, Tanja Lange
topic: Post-Quantum Cryptography
video: https://www.youtube.com/watch?v=6XeBvdm8vao
length: ~60 minutes

A gentle introduction to post-quantum cryptography

Last year your friend Karen joined the alternative music scene and sent you a sound track. The government is recording everything, and this year announced that alternative music is a gateway drug to terrorism (see http://www.theguardian.com/australia-news/2015/sep/25/radicalisation-kit-links-activism-and-alternative-music-scene-to-extremism). Fortunately, Karen encrypted the email.

Fast forward to 2035. Stasi 2.0 has risen to power and has decided that, to protect society, anyone who has ever been exposed to alternative music will be sent to a „better place“. They still have a copy of Karen’s ciphertext. And here’s the really bad news: They’ve just finished building a billion-qubit quantum computer.

Back in 2015, large general-purpose quantum computers haven’t been built yet, but the consensus is that they will be built, and that they will allow well-funded attackers to retroactively break practically all of today's deployed public-key cryptography.
RSA will be dead.
ECC will be dead.
DSA will be dead.
„Perfect forward secrecy“, despite its name, won’t help.

Fortunately, there are replacement public-key cryptosystems
that have held up very well against analysis of possible attacks,
including future quantum attacks.
This talk will take a hands-on look at the two examples
with the longest track records: namely, hash-based signatures (Merkle trees) and code-based encryption (McEliece).

The talk will be given as a joint presentation by Daniel J. Bernstein and Tanja Lange.

speaker: János Pásztor
topic: How (not) to document
video: https://www.youtube.com/watch?v=wKA_Ehx7awo
length: 47 min
audio quality: good

Let’s face it: writing documentation is fundamentally boring. Unless you’re a total graphomaniac, chances are you are not writing as much documentation as you should be, or if you do, you find it hard to organize it in a useful manner. Grab a cup of coffee and join me on a journey of the good, the bad and the ugly parts of writing documentation. By the time we are finished, you will find writing and reading documentation a lot easier.

About János Pásztor: even though he likes tinkering with technology as much as the next guy, during the last year his focus has shifted to documenting existing technologies, quirks and most importantly: business requirements. Unsatisfied with existing state of most documentation, he tries to apply visuals to make documentation work better.

speaker: László Merklik
topic: Continuous Delivery - máshogy már nem lehet (HU)
video: https://www.youtube.com/watch?v=D98T-y1efJk

This is a Hungarian-speaking event.

Arról lesz szó, hogy hogyan lehet biztonságosan kísérletezni production környezetben; hogy mire érdemes figyelni adatbázis változtatások kiadásánál; hogy mi a tesztelés és a monitorozás helyes aránya; hogy mi az a flipper-hell és hogyan kerülhetjük el; hogyan támogatja a felhő-alapú SOA(Service Oriented Architecture) a folyamatos kiadást.

speaker: Christian Schaffner
topic: Quantum Cryptography
video: https://www.youtube.com/watch?v=424LHQQB2DE
length: ~60 minutes

I will entertain the audience with a science talk about quantum cryptography, covering both some classics (Quantum Key Distribution) and the latest developments (position-based quantum cryptography) in this fascinating research field.

(No previous knowledge of quantum mechanics is required to follow the talk.)

The most well-known application of quantum cryptography is Quantum Key Distribution (QKD) which was invented in 1984 by Bennett and Brassard. QKD allows two players Alice and Bob to securely communicate over an insecure line which is overheard by an eavesdropper Eve. Security can be proven in an information-theoretic sense against an unrestricted Eve. Such a high level of security is impossible to achieve with classical communication. In the first part of the talk, I will introduce some basic concepts of quantum information theory in order to understand and appreciate the security of QKD.

However, quantum cryptography offers a wide range of other applications that go beyond the task of key distribution. For instance, the goal of “position-based cryptography” is to use a player’s physical position as cryptographic credential. The combination of relativistic constraints (assuring that information cannot travel faster than the speed of light) and quantum mechanical effects (such as the impossibility to perfectly copy a quantum state) enables entirely new cryptographic applications like sending a message in such a way that it can only be read at a particular geographic position. In the second part, I will introduce you to this intriguing new branch of quantum cryptography.

speaker: Douglas Crockford
topic: Upgrading the Web
video: https://www.youtube.com/watch?v=YRo2GStE3Qg
length: 1 hour

The web was originally imagined to be a simple distributed document retrieval system. It is now being used for applications that go far beyond the system’s original capabilities and intentions. We have found ways to make it work, but they are difficult and far too fragile. Many times companies have offered to replace the web with superior proprietary systems, but we rejected them. We have been adding features to the web, but this does little to correct the deep underlying deficiencies, increasing instead of reducing its complexity.

This talk suggests a way forward, taking inspiration from our successful transition from NTSC to HDTV. There is a way forward to a web that is safer, easier, and as good as we desire.

Douglas Crockford
Senior JavaScript Architect, PayPal, creator of JSON-js.

Check out all our events at FITC, Twitter.

speaker: Nicolas Gregoire
topic: Server-Side Browsing Considered Harmful
video: https://www.youtube.com/watch?v=8t5-A4ASTIU

SSRF vulnerabilities (aka CWE-918) allows attackers to submit arbitrary URL to vulnerable applications, and have the application (or one of its components) browse this URL. The talk describes my latest findings regarding this narrow field of AppSec. Of course, being under NDA during my penetration tests, I'll only covering bugs reported to bounties programs. That includes Yahoo, Facebook, Prezi, PayPal, Stripe, CoinBase, and more!

6 sections:

• Goal: SSRF-like vulnerabilities in bounties programs
• Vectors: WebHooks, export features, API explorers, ...
• Targets: local, multicast and private destinations
• Blacklists: the 20+ ways to express an IP address
• Bugs: contexts, exploits, impacts and rewards
• Toolbox: custom scripts and public resources

Highlights: I was able to compromise some large service providers and earned around 50,000$ for that. Several blacklists were bypassed using little-known quirks in the parsing of URL.

speaker: David Manning
topic: Practical Optimization for V8
video: https://www.youtube.com/watch?v=Mg-QIwMqLyg

Writing Javascript is fun, but writing performant code that makes efficient use of v8’s JIT compiler is a dark and arcane art. In the absence of clear answers, misinformation and superstition abound. Can we trust microbenchmarks? Should we try to write Javascript like C++? Can sacrificing a chicken on the first full moon of Spring really reduce garbage collection cycles? My talk will absolutely not settle all of these debates!

speaker: Michael "Doc" Norton
topic: Agile Metrics - Velocity is NOT the Goal
video: https://vimeo.com/97505655

Velocity is one of the most common metrics used-and one of the most commonly misused-on agile projects. Velocity is simply a measurement of speed in a given direction-the rate at which a team is delivering toward a product release. As with a vehicle en route to a particular destination, increasing the speed may appear to ensure a timely arrival. However, that assumption is dangerous because it ignores the risks with higher speeds. And while it’s easy to increase a vehicle’s speed, where exactly is the accelerator on a software team?
Michael “Doc" Norton walks us through the Hawthorne Effect and Goodhart’s Law to explain why setting goals for velocity can actually hurt a project's chances. Take a look at what can negatively impact velocity, ways to stabilize fluctuating velocity, and methods to improve velocity without the risks. Leave with a toolkit of additional metrics that, coupled with velocity, give a better view of the project's overall health.

speaker: Martin Fowler
topic: Not Just Code Monkeys
video: https://www.youtube.com/watch?v=Z8aECe4lp44

This is the second part of Martin Fowlers keynote at OOP 2014 in Munich and is a tricky talk to describe. Usually Martin likes a title and abstract to describe what the talk is about - but this talk is a journey, and he doesn't want to tell you where he's going, but instead to explore the ground with him. Martin Fowler will say that it starts with his biggest problem with most adoption of agile software development - the nature of the interaction between users, analysts, and programmers. It goes on to explore these roles, raising questions about the relationship of programmers to users, our responsibilities to them, and finally the Two Great Challenges that I think programmers need to face up to.

More information about Martin Fowler
More information about OOP Conference

speaker: Kevlin Henney
topic: Programming with GUTs
video: http://www.infoq.com/presentations/testing-communication
issue: 31

Kevlin Henney advises on writing Good Unit Tests (GUTs) by treating testing as a form of communication with multiple levels and forms of feedback.

speaker: Jeff Whelpley, Patrick Stapleton
topic: Angular 2 Server Rendering
video: https://www.youtube.com/watch?v=0wvZ7gakqV4

Jeff Whelpley, Patrick Stapleton Talk about 'Angular 2 Server Rendering' at AngularU in San Francisco.

Angular2 was built from the ground up to potentially run anywhere, including your web server. In this talk, we will go through the implications of this design and demonstrate the power of rendering your Angular2 app on the server.

• Session Details
• Session Photos
• Angular U site

speaker: Jocelyn Goldfein
topic: Products That Count: Form follows function
video: http://vimeo.com/118874750

Facebook’s ex-head of mobile development Jocelyn Goldfein shares best practices in building great software companies and cultures. "Your business model and technology stack shape your software company’s DNA and culture. You should understand how and why."

speaker: Jacob Page
topic: Writing elegant UI code with FRP
video: https://www.youtube.com/watch?v=jF4nXiALYtY
length: 28 minutes

Functional Reactive Programming, you can merge all the async things into one unified interface, streams of events. Then take these streams and elegantly transform and combine them with operations like map, filter, combine, merge, and throttle.

speaker: Maciej Ceglowski
topic: Web Design: The First 100 Years
video: https://www.youtube.com/watch?v=nwhZ3KEqUlw

Join Maciej Ceglowski for an insightful look “back” at web design’s beginnings, from the perspective of someone 100 years in the future. You’ll see how the web is evolving in ways nobody expected, and how you can design with the future in mind.

It’s normal for a new medium to be in a state of flux, but the situation is particularly acute for those of us working online, since the constraints we work under are not physical. The medium changes whenever the code changes, and the code changes all the time. What lessons can we take from other media about how to manage this dizzying rate of change? And how can we hope to do lasting work in a medium so obsessed with novelty? Enjoy this report from the year 2110 on attempts to reconstruct what the early web must have looked like.

speaker: Charles Galambos
topic: Reinforcement Learning and its use in real-time applications
video: https://skillsmatter.com/skillscasts/6462-reinforcement-learning-and-its-use-in-real-time-applications#

Reinforcement Learning is a powerful technique for identifying the best actions to take to achieve a goal.

In this talk you will see some of the algorithms used to learn effective behaviours. In particular I will look at temporal differencing and how it can be used in conjunction with a recurrent neural network in a real time environment.

speaker: Hunter Loftis
topic: We Will All Be Game Programmers
video: https://www.youtube.com/watch?v=avwDj3KRuLc
issue: 10

Hunter Loftis is responsible for the Node.js platform at Heroku. When he’s not working at Heroku, he runs PlayfulJS, a website of cool JavaScript code snippets.

One of the better well-known demos on PlayfulJS is a re-creation of the Doom rendering engine in JavaScript. After building this, Hunter was contacted by Warp records about building a first-person shooter in JavaScript.

One of the issues with this request was the timeframe — three weeks to build the game to coincide with an album release, and with a tiny budget. On top of that, the game had to work on desktop, Android, and iOS. So, Hunter rationalized and decided to accept the project.

After accepting the project for what he thought would be a small, indie release, Hunter realized that the artist (Rustie) was huge in the UK and overseas, and this release would be a huge deal.

JavaScript Training from NewCircle here

speaker: James Lewis
topic: Microservices - Systems That Are #neverdone
video: https://www.youtube.com/watch?v=1djcreLdhmA
length: 57 min

James Lewis is a Principal Consultant for ThoughtWorks UK. He has helped introduce evolutionary architecture practices and agile software development techniques to various blue chip companies: investment banks, publishers and media organisations. James Lewis studied Astrophysics in the 90’s but got sick of programming in Fortran.

The software industry is changing faster than ever. Now, with microservices becoming more and more accepted as an architectural style, the rate of change of our industry and of the software we write is going to go one way, up.

In his keynote, James explores what this means for developers writing code now. Do we abandon our quest to build quality in? What does it mean for design if we are building software explicitly to throw it away a short time later. Is TDD dead? What does software craftsmanship look like through the lens of replaceable code in small replaceable services?

Check out more about I T.A.K.E. Unconference.

speaker: Bjarne Stroustrup
topic: Writing Good C++14
video: https://www.youtube.com/watch?v=1OEu9C51K2A

How do we use C++14 to make our code better, rather than just different? How do we do so on a grand scale, rather than just for exceptional programmers? We need guidelines to help us progress from older styles, such as “C with Classes”, C, “pure OO”, etc. We need articulated rules to save us from each having to discover them for ourselves. Ideally, they should be machine-checkable, yet adjustable to serve specific needs.

In this talk, I describe a style of guidelines that can be deployed to help most C++ programmers. There could not be a single complete set of rules for everybody, but we are developing a set of rules for most C++ use. This core can be augmented with rules for specific application domains such as embedded systems and systems with stringent security requirements. The rules are prescriptive rather than merely sets of prohibitions, and about much more than code layout. I describe what the rules currently cover (e.g., interfaces, functions, resource management, and pointers). I describe tools and a few simple classes that can be used to support the guidelines.

The core guidelines and a guideline support library reference implementation will be open source projects freely available on all major platforms (initially, GCC, Clang, and Microsoft).

Presentation Slides, PDFs, Source Code and other presenter materials are available

speaker: David Mark Clements
topic: Growing up with JavaScript: History & Future of an Oddball
video: https://skillsmatter.com/skillscasts/6271-growing-up-with-javascript-history-future-of-an-oddball

Want to see what all the fuss is about in Node.js? Join David Mark Clement, technology expert in JavaScript and Node for an evening's walk through some of the bleeding edge features of Javascript. Set within the context of David's experience growing up with Javascript since the mid 90's, this talk aims to provide non-js programmers a comfortable entry point into the language as well as equipping js-programmers with new tools.

Join David Mark Clements at Skills Matter to learn and share javascript skills including Node and io.js and to enjoy some interesting technical facts contextualised in the history of the language.

speaker: Ádám Balogh
topic: Rest Key Concepts
video: https://www.youtube.com/watch?v=9gou0ta3os4
issue: 20

Hungarian-speaking video.

This presentation is about the RESTful services.

Warning: the audio quality of the first 5 minutes is bad, but after that is good enough.

speaker: Armin Ronacher
topic: 5 Years of Bad Ideas
video: https://www.youtube.com/watch?v=8e0l_Dt28MQ

What was my motivation for working with Python after two years of PHP? There is so much you can do. Functions are objects you can pass around, you can decompile functions to see how they work internally, you can alias a bound method to a global function and it will just work. You can change import semantics, override the method resolution order, you can write metaclasses, you can hook into the CPython interpreter API and much more.

Five years later I came to the conclusion that this is really not what Python is about and that a lot of what I did was interesting but not necessarily a good idea. This talk is a 45 minute recompilation of things I really shouldn’t have done in the first place. Expect a bunch of neat and interesting hacks that showcase the possibilities of the language.

speaker: Woody Zuill
topic: Mob Programming - A Whole Team Approach
video: https://www.youtube.com/watch?v=OWcKSletcOU
length: 1 hour 2 minutes

Mob programming is a development approach in which the whole team works on the same thing at the same time, in the same space, and at the same computer. This is a whole team approach to doing all the work the team does—including coding, designing, testing, and working with the customers (stakeholders, product owners, users, and so on). This session takes a look at the practice and explores the benefits and some ideas you can try on your own team.

speaker: Ernie Miller
topic: How to Build a Skyscraper
video: https://www.youtube.com/watch?v=7MeBuDLbF98
length: 45 min

Since 1884, humans have been building skyscrapers. This means that we had 6 decades of skyscraper-building experience before we started building software (depending on your definition of “software”). Maybe there are some lessons we can learn from past experience?

This talk won’t make you an expert skyscraper-builder, but you might just come away with a different perspective on how you build software.

This presentation was held at Full Stack Fest 2015.

https://www.youtube.com/watch?v=f84n5oFoZBc

Rich Hickey's second, "philosophical" talk at the first Clojure Conj, in Durham, North Carolina on October 23rd, 2010.

Full transcript is here

(Image source is here)

speaker: Zoltán Ormándi
topic: TDD Anti-Patterns (HU)
video: https://www.youtube.com/watch?v=Odn2Z2XAhCk

This is a Hungarian-speaking event.

Az előadásában a TDD kerül előtérbe, mely szerencsére már nem csak egy trendi újdonság, hanem kezd elfogadott standard lenni a szoftverfejlesztői szakmában Magyarországon is. Zoli az elmúlt 10-15 év tapasztalatait osztja meg velünk arról, hogyan érdemes TDD-zni, kiemelt figyelmet fordítva a módszertan elrettentően rossz alkalmazásaira.

speaker: Gary Bernhardt
topic: The birth and death of JavaScript
video: https://www.destroyallsoftware.com/talks/the-birth-and-death-of-javascript
length: 30 minute

This science fiction / comedy / absurdist / completely serious talk traces the history of JavaScript, and programming in general, from 1995 until 2035. It's not pro- or anti-JavaScript; the language's flaws are discussed frankly, but its ultimate impact on the industry is tremendously positive. For Gary's more serious (and less futuristic) thoughts on programming, try some Destroy All Software screencasts.

speaker: Brad Green, Igor Minar and Jules Kremer
topic: Angular Connect Keynote
video: https://www.youtube.com/watch?v=UxjgUjVpe24
length: 1h 3 min

AngularConnect is a two-day, multi-track conference featuring talks from the world’s leading Angular experts, including the core Angular team from Google.

• Ionic 2 is out
• Angular 2 will support IE9
• Great competition is provided by Google: Angular + Cardboard
• Angular 2's performance is just amazing
• Batarangle for Angular 2 is under development it's available on github
• Angular CLI is just awesome - http://ngcli.github.io/