Friday, 30 December 2016

Clean Code III: Functions - Robert C. Martin


Get ready for a challenge as Robert Martin dives deep into the topic of clean Java code by examining what makes a good function. In this talk you will look at a lot of code; some good and some bad. You will experience how such code is analyzed, critiqued, and eventually refactored. You will understand the decisions made by an expert in the field as bad code is gradually transformed into good code. How big should a function be? How should it be named? How should it be documented. How many indent levels should it have? How should it deal with exceptions, arguments, and return values. This talk is all about code at the lowest level. And yet the principles and techniques presented have far reaching implications.

source: ndc

Monday, 19 December 2016

Mining Repository Data to Debug Software Development Teams - Elmar Juergens


If the team architecture and the technical architecture do not fit together, problems arise. Both architectures evolve, however, often causing misalignment. How can we notice such mismatches and react in time?
In this talk, I present modern analysis techniques that mine data from different software artifacts (e.g. lightweight architecture specifications, code and trace files) and version control systems. They reveal problems in the code or design that result from communication problems in the development team.
I present the analysis techniques using examples from open source and commercial software systems. I also outline both best practices and limitations in employing such analyses that I collected over 10 years.

source: goto

Friday, 16 December 2016

Authentication & secure API access for native & mobile Applications - Dominick Baier



Modern native & mobile applications have requirements like authenticating a user and securely accessing APIs on behalf of that user. Since those application types have access to advanced platform and OS features like cryptography and secure storage we can enable advanced features like mobile single sign-on, seamless token lifetime management and other advanced security features. The OpenID Connect and OAuth 2.0 hybrid flow alongside some new specification like PKCE and PoP are a perfect match for these scenarios.


source: ndc

Thursday, 15 December 2016

Upgrading JavaScript to ES6 and using TypeScript as a shortcut - Chris Heilmann


ECMAScript* (insert 6, 2015, 7, 2016, whatever here) is a hot topic and rightfully in the spotlight. After 15 years of weird ups and downs we now have a ratified version of the language that powers the web. ES6 answers many demands developers had and our products need, but it still suffers from the issue that not all runtimes support it.
Instead of waiting for everyone to upgrade or blocking out users we have the option to transpile or to choose a subset of JS to achieve compliance with our needs and wants. In this talk Chris Heilmann shows the pros and cons of these approaches.


source: ndc

Wednesday, 14 December 2016

Safe at Any Speed - Ian Cooper




Ian Cooper has over 20 years of experience delivering Microsoft platform solutions in government, healthcare, and finance. During that time he has worked for the DTI, Reuters, Sungard, Misys, Beazley, and Huddle delivering everything from bespoke enterprise solutions, ‘shrink-wrapped’ products, and cloud services to thousands of customers. Ian is a passionate exponent of Software Craftsmanship and Agile Architecture. When he is not writing code he is also the and founder of the London .NET user group and speaks at events throughout the UK.

source: buildstuff

Tuesday, 13 December 2016

Yesterday’s Technology is Dead, Today’s is on Life Support - Troy Hunt


Isn’t technology just awesome? Well we think it’s awesome and then a year or two later it’s old junk that for most of us, serves no further useful purposes. The technology of yesterday is rapidly becoming unrecognisable not just in the sense that it’s so different to what we use today, but a whole generation has literally never even seen a cassette tape or a rotary dial phone before.

Looked at the other way, our present day technology was inconceivable such a short time ago. What we take for granted today was little more than a pipedream yesterday yet our lives would be unrecognisable without them. Our children could not conceive of a time without mobile phones or internet; there are adults today that have not known this time!

This talk delves into how technology is changing around us from the essential to the absurd. Technology we put in our homes, technology we carry, technology we insert inside ourselves and all of it headed for rapid obsoletion as the next inconceivable wave takes hold. As much as yesterday’s technology is dead, today’s is on life support and we’d better get ready for the next big thing.

source: ndc

Monday, 12 December 2016

Teaching Kids Programming - Lynn Langit


In this talk, director of the non-profit 'Teaching Kids Programming', Lynn Langit will share her experience teaching kids coding around the world over the past 8 years. Starting when she worked at Microsoft, with the DigiGirlz program, Lynn has been creating courseware, teaching teachers and teaching kids core computational concepts.

Lynn will discuss and demonstrate key concepts using example from TKP courseware (core is in Java). Teaching methods are based on Agile / XP technical practices and include pair and mob programming, TDD, katas, koans and more.

Attend this session to learn what works with teachers and kids and to learn how you can make a difference teaching the next generation of programmers.


source: ndc

Sunday, 11 December 2016

Domain Architecture Isomorphism and the Inverse Conway Maneuver - Dylan Beattie


Most of us have come across Conway's Law - the observation that "organisations that design systems are constrained to produce designs which are copies of the communication structures of those organisations". From standalone web applications to open-source projects to large-scale enterprise applications, a project's success (or failure) comes down to the team that's trying to deliver it - so why do so many projects try to impose the right architecture on the wrong team structure?

Once you accept the the tendency for systems to end up reflecting the structure of the teams that build them, it becomes clear why a lot of software projects don't go according to plan. Your architect says you're going to use an API instead of direct database access - but then you sit your back-end developers right next to your DBA and give them a deadline to hit. What do you think's going to happen to your abstraction layer? Or you decide you're going to have an API team in London working with an app developer in Belarus and a web team in Ukraine, and then you wonder why your system's communication layers are causing performance problems?

In this talk, Dylan explores the idea that we should be designing our systems first, and then restructuring our teams to reflect the system design. We'll look at some common communication structures - including some things you probably do already that you never realised were communication structures - and how those structures affect the outcome of the systems they help to build. We'll discuss how you can apply common patterns to your teams as well as your code, and we'll talk about how to sell the idea to your boss before you start moving desks around.

source: ndc

Saturday, 10 December 2016

Messaging and Microservices - Clemens Vasters

 

Microservices are the new hot topic in the industry, and yet they are based on foundational principles of service orientation as formulated in the early 2000s, and those were in turn based on experience and insights from building messaging-oriented systems in previous decades. In this talk, Clemens Vasters, Architect for Messaging at Microsoft Corporation is going to talk about the eternal truths and proven patterns of messaging, and about how messaging helps Microservices-architecture based systems achieve operational objectives.


source: goto

Friday, 9 December 2016

The Error of Our Ways - Kevlin Henney



What happens when things break? What happens when software fails? We regard it as a normal and personal inconvenience when apps crash or servers become unavailable, but what are the implications beyond the individual user? Is software reliability simply a business decision or does it have economic, social and cultural consequences? What are the moral and practical implications for software developers? And when we talk of 'systems', are we part of the 'system'? What about the bugs on our side of the keyboard? In this talk we will explore examples of failures in software and its application, and how they affect us at different scales, from user to society.

source: goto

Thursday, 8 December 2016

Ryan Ripley - The Business of Agile: Better, Faster, Cheaper - Ryan Ripley


During my last agile transformation a key stakeholder asked me, “Why are we doing this?” I talked about increasing quality, delivering software sooner, and fostering a more collaborative relationship with our business partners. After a few minutes, he raised his hand and stopped me.
“I get all that. BUT how is all of this agile stuff any better, faster, or cheaper than what we do today?”

Leaders must answer the “better, faster, cheaper” question if they want their agile transformation and projects to move forward.

To prepare leaders for this critical question, we explore how “better, faster, cheaper” translates to an agile organization, the metrics a leader can use to track progress towards “better, faster, and cheaper”, and how leaders can demonstrate the benefits gained from their agile activities.


source: cohaaorg

Wednesday, 7 December 2016

Debugging your communication for more success and efficiency in DevOps - Sabine Wojcieszak


In this talk we will focus on the role of communication for a DevOps team, although we will also touch psychological aspects of mindset, attitude and behavior!
Whenever people come together, communications starts at once! You can´t stop it! In addition to the original face-to-face communication we use a lot of different communication channels like phones, chats, live webinars and emails in our modern times.
As communication is a very complex topic misunderstanding is part of daily our work; it is always the companion of communication. We have to spend a lot of time to deal with these misunderstandings or - what is worse - things will go wrong.
The more different characters work together in cross-functional teams like DevOps the higher the probability of misunderstanding. With release cycles getting shorter and shorter or continuous delivery, time is a very precious factor in IT projects. So why do we waste time in clearing up misunderstanding? For more success and more efficiency it will be extremely helpful to identify the bugs in your communication and eliminate them to reduce misunderstandings and save time! And we will talk about the nearly unbelievable effect on everyone´s motivation.
In this session theoretical background will be combined with best practice; the importance of further education in communication skills especially for “people from IT” to reach more efficiency will be pointed out.

The takeaways for the audience:
- what is beyond organizational change and tools when doing / being DevOps
- the importance of communication and the difficulties
- bugs and misunderstanding
- smart ways to eliminate bugs in order to create a successful and efficient communication
- communication as part of culture, attitude and motivation
- Best practice of slight but successful improvement of communication and the effect on everyone in a company

source: NDC

Tuesday, 6 December 2016

The Future of Visual Studio (Visual Studio "15" Preview) - Amanda Silver



Come to hear the future of Visual Studio. This session will illustrate how Visual Studio is evolving demo by demo. We’ll show you the latest capabilities to enable any developer to build any apps. We’ll provide a preview of the streamlined acquisition experience for the next release of Visual Studio. You will see the cutting edge features we are working on to bring your productivity to the next level. We’ll even provide a back stage peek into how we’re using your feedback to continuously improve Visual Studio.

source: build

Monday, 5 December 2016

Foolproofing your UI & UX - Jessica Engström


Can you foolproof your design?
How do you design your app to be noticed and feel beautiful and harmonious?
UI & UX is commonly thought about at the last stages of developing. I say that you should incorporate this already from the beginning to save time and code.
I will take you through the planning stage, how to choose what elements to use, how to polish your design and finishing off with the testing stage.


source: ndc

Sunday, 4 December 2016

Less - The Path to Better Design - Sandi Metz


The concrete principles of Object Oriented Design are useful but are built upon powerful concepts that the principles tend to obscure. When design principles become goals in and of themselves, object oriented design gets a bad name and applications suffer. This talk strips away the well-known design principles and exposes the hidden, underlying goals of design. It reveals programming techniques that allow you to write less code while creating beautiful, flexible applications.

source: ndc

Saturday, 3 December 2016

A Pragmatic Approach to Microservices with Axon Framework - Allard Buijze



Most discussions about the implementation of a microservices based infrastructure start by evaluating the various technical options and challenges that it comes with. However, the real business value isn’t in these technical choices, but in the functionality. Axon Framework helps developers build a message driven, modular application using the architectural principles of Domain Driven Design (DDD), Command-Query Responsibility Segregation (CQRS) and Event Sourcing. It allows developers to focus on the functionality of an application first, and naturally evolve the application to meet non-functional requirements as the need arises.

In this session, you will see what such an application looks like, how to easily set it up using the new features of Axon 3, and how to evolve the application into microservices.

source: goto

Friday, 2 December 2016

The Future of Software Engineering - Mary Poppendieck


2020 used to be far in the future. Today it’s four years away. We no longer need to guess what breakthroughs await us in that magic year, the future is hiding in plain sight: a reliable Cloud, industry-disrupting Platforms, massive data from the Internet of Things, really useful Artificial Intelligence, surprising Virtual Reality...

The question is not what the technologies of 2020 will be – that is rapidly coming into focus. The real question is: What is value? What’s important, what isn’t, and why? Should you focus on Continuous Delivery? DevOps? How do you get from where you are now to where you need to be? How do you scale? How do you keep your systems reliable and secure?

This talk will discuss how software engineering is changed by the emerging digital technologies.

source: goto

Thursday, 1 December 2016

Soft Skills for the Developer - Mahesh Krishnan


In the eyes of a lot of people, "the stereotypical developer" is an introvert, who spends all of his or her time in front of a computer, communicates poorly, is socially awkward, unreliable, wears esoteric T-shirts and has an addiction to caffeine.
Of course, this is not (all) true, but as developers our coding skills far outweigh our "soft" skills. So, what do we, as developers, need to do to improve on these skills?
Mahesh Krishnan, draws upon his years of experience as a developer and consultant to talk about these skills, and what you need to do to get them. He will provide you with tools and tips to help you with your confidence, communication skills, time management skills, how to resolve conflict, etc; and also what you need to do to advance both your technical and leadership skills.

source: ndc

Wednesday, 30 November 2016

Beyond console.log - Aaron Powell


Whether you're a Chrome, FireFox, Edge or Safari kind of person you've probably opened up the web developer tools at some point... but is your extent of usage writing console.log within your code and inspecting an element, or have you gone deep?
For this session we'll be diving into the tips and tricks that will make you a power user when it comes to your browser dev tools, explore the console beyond console.log, learn the differences between the different browser tooling and how to find that damn problem that's only happening on !


source: ndc

Tuesday, 29 November 2016

Agile & Lean: A Marriage to Maximize the Value of IT - Guruprasad Vasudeva



Five years ago, Nationwide embarked on a journey to implement agile and lean practices at an enterprise scale. Join Guru for a look into the real-life experiences of leading this transformation across several application development and maintenance efforts. He will highlight the integration of agile and lean practices and the importance of lean leadership to measure and track the economic value of these techniques. Along the way, he will also reflect on the versatility of lean and his personal journey applying lean concepts.

source: cohaaorg

Monday, 28 November 2016

Visual Studio 2016 + Talk DevOps please - Adam Cogan


Visual Studio 2016 + Talk DevOps please: A .NET Developers Guide to 3rd Party tools for DevOps
Find out what Microsoft has planned for developers in 2016 with the new Visual Studio 15 IDE then talk DevOps.
DevOps is all about bringing the developers and operations together so that they are working as a team in the best interests of the product rather than themselves. Let's talk about the main goals you want to achieve by implementing good DevOps.
Things are looking better with the open sourcing of .NET and ASP.NET along with the release of the free Visual Studio Community Edition but you still need 3rd party tools for great devops. Come see Adam give you a tour and expand your development horizons that will include 15 tools starting with Azure Deployment Slots, Octopus, Testing in Production and more.

source: ndc

Sunday, 27 November 2016

Re-thinking IT - John Seddon


Pursuing an unquestioning belief in economy of scale, managers of service organisations have industrialised their operations. Front- and back-offices, glued together by IT systems are now the norm. But being normal is not the same as being right.
John will outline the counter-intuitive truths, describe the systems approach to organisational change and will argue for a different way to develop IT that costs less and delivers more. Prepare to be challenged, disturbed and inspired.

source: oredev

Friday, 25 November 2016

Debugging Your Website with Fiddler and Chrome Developer Tools - Robert Boedigheimer


Debugging web sites can be tricky, but tools like Chrome Developer Tools and Fiddler continue to improve.Chrome provides a great client side JavaScript debugging experience. It also shows the live DOM and is often the only way to determine exactly what style rules have been applied in CSS.
The network tab provides basic details on requests and responses for the page, including the “initiator” column that indicates why the request was made.The tools provide profilers, audits, and the ability to throttle the network connection. It also provides basic emulation of device sizes for web pages. Fiddler can also be extremely helpful when debugging as traffic can be modified manually or programmatically. The auto responder feature can mock particular responses to web requests, or add specific delays for latency. The composer can construct specific requests that are difficult to create with browsers directly. Fiddler is also extremely helpful for capturing and modifying traffic from smartphones, tablets, and non-Windows platforms. Together these free tools make it much easier to troubleshoot problems with today’s complex multi-device web sites.

source: ndc

Thursday, 24 November 2016

DevOps @bol.com: Our Journey to Grow from 10 to 50 Teams in 3 Years - M. Tunaru & M. Vis


bol.com experienced a tremendous growth in the past years coupled with growth in the number of scrum teams. We witnessed our IT department grow from 10 to 30 teams in just two years time.
Our speed of innovation was accelerating but at the same time we needed to excel in operational excellence. Our current way of working became more and more difficult and we reached the conclusion we had to make significant changes in how we design, build, deploy and operate all our applications.
Hence we determined and implemented our own vision on DevOps during 2015. This has been a challenging and interesting journey to team autonomy and is in full swing right now. We had to adopt the way we work, how we organize ourselves and we invested in new technologies to ‘automize’ the (now) over 45 teams.

We would like to share with you our story: how we initiated the journey, how we progressed and what we have learned. We will approach it from two angles: a manager’s view and a software development team’s perspective.

source: goto

Wednesday, 23 November 2016

Jezen Thomas - Haskell on Rails





Jezen Thomas is a software developer, writer, and public speaker spending most of his time building things for the Internet with Ruby, JavaScript, and Haskell. He currently works remotely from the North coast of Poland, leading user interface development at Syft, a hospitality recruitment startup in London. His work has spanned a variety of industries and countries, and his writing has appeared in a few major tech journals including SitePoint and the Telerik Developer Network. His development interests include Unix, Vim, TDD, functional programming, simplicity, and boiling problems down to their raw components. Aside from programming, Jezen's passions include music, cars, and the search for the perfect driving road.

source: Build Stuff

Tuesday, 22 November 2016

Orleans Architecture Patterns - Sergey Bykov and John Azariah


How to build real-world applications with Orleans.
You've probably heard of Orleans as the open-source framework Microsoft uses to build cloud-scale services for products, such as Halo and Skype.
But how do you use it effectively in your own applications?
In this architecture talk, John & Sergey discuss several challenges that you will face when building cloud services; introduce several proven, powerful design patterns & practices such as state-machines, smart-caches, and event-sourcing; and some anti-patterns to avoid.

source: NDC

Monday, 21 November 2016

Being Agile: Having the Mindset that Delivers - Gil Broza


Are you excited about adopting Agile? Have you put in place the roles, artifacts, practices, and tools? Are you then realizing the promised benefits – happy customers, quality product, reliable delivery teams, and faster releases?

If instead of an emphatic “yes,” your honest answer is “only some of the benefits,” “inconsistently,” or “we did, initially”, then you’re not alone. Most organizations experience this due to an Agile implementation that is mechanical, rigid, driven by tools and so-called “best practices.” But Agile is much more than a process; it’s first and foremost a mind-set that permeates your actions. Without the mind-set, the practices don’t matter, and you won’t achieve *and sustain* great results.

In this talk, Gil Broza will guide you through an exploration of the values, beliefs, and principles that define Agile thinking. You’ll learn how to choose Agile-minded methods, process, and practices for your needs and context. And with the deep understanding of what makes Agile work, you’ll be able to support mindful implementation and the necessary culture change.

source: cohaaorg

Saturday, 19 November 2016

Docker and ServiceFabric - A taste of two platforms - Michele Bustamante


Docker is somewhat of a poster child for the microservices wave but ServiceFabric is a very interesting PaaS alternative at the other extreme.
While there are many options in the middle, including various container services platforms, this session focuses on comparing the two from a developer and DevOps perspective noting design, development, topology and deployment lifecycle differences.

source: ndc

Friday, 18 November 2016

Object-Oriented Programming is Bad - Brian Will


An explanation of why you should favor procedural programming over Object-Oriented Programming (OOP).

Source: Brian Will

Thursday, 17 November 2016

Unit testing patterns for concurrent code - Dror Helper



Getting started with unit testing is not hard, the only problem is that most programs are more than a simple calculator with two parameters and a returns value that is easy to verify.
Writing unit tests for multi-threaded code is harder still.
Over the years I discovered useful patterns that helped me to test multi-threaded and asynchronous code and enabled the creation of deterministic, simple and robust unit tests.
Come learn how to test code that uses concurrency and parallelism – so that the excuses of not writing unit tests for such code would become as obsolete as a single core processors.

Source: NDC

Wednesday, 16 November 2016

Hack yourself first: go on the cyber-offence before online attackers do - Troy Hunt


The prevalence of online attacks against websites has accelerated quickly recently and the same risks continue to be exploited. However, these are often easily identified directly within the browser; it's just a matter of understanding the vulnerable patterns to look for.

'Hack Yourself First' is all about developers building up cyber-offence skills and proactively seeking out security vulnerabilities in their own websites before an attacker does. It recognises that we have huge volumes of existing websites that haven't gone through sufficient security review plus we continue to create new content that even when built with security in mind, still needs testing from the perspective of a cybercriminal.

In this session we'll look at website security from the attacker's perspective and exploit common risks in a vulnerable web application. We'll also explore ways to easily grab credit cards, gain immediate FTP access to thousands of websites and even look at how your toilet can be pwned.

Source: codemania

Tuesday, 15 November 2016

ASP.NET Identity 3 - Brock Allen




ASP.NET Identity 3 has had a bit of an update in ASP.NET Core. To get started with this framework most developers use the Visual Studio project templates, which have historically been ridiculed for the mountains of code dumped into a new project.
In this session we will spend the time to understand it all (since that’s what most developers end up using). Along the way we will see features that are the same as the prior version of ASP.NET Identity, but there are some new features to point out in this updated ASP.NET Core based framework. Additionally, as the templates are examined, we will discuss changes that can be made to lock down the security of your application even more. Finally, some freestyle coding might be in order to add even more security features than what are provided out of the box.

Source: NDC

Monday, 14 November 2016

Get Momentum: Five Questions to Ask to Get Started - Jason Womack



After more than 14 hours together, we’re all about to leave this year’s conference with more ideas than we can remember and more to-dos than we’ll have time to do. How do you prioritize? How do you make sure that what you DO do is the best thing TO do? And, what can you do as a result of attending this conference to continue learning, developing and experimenting with agile?

Jason knows how powerful a well-crafted and well-placed question can be. Starting in 2001, when a college professor asked Jason a single question that changed the direction of his life until just last month when his 4th book was published, Jason has been studying the impact of thinking about thinking. And, taking micro-actions to improve your work and your life. Be sure you get a copy of his book, and join him as he closes the conference sharing with us the 5 questions to ask to get anything started.

Source: cohaaorg

Sunday, 13 November 2016

C#’s Greatest Mistakes - Jon Skeet



C# is a lovely language in many ways, but it's not perfect. Mistakes made early in a language or platform's development are often impossible to fix afterwards, so this talk isn't a set of suggestions for the C# team. Instead it's a reflection on what we might do if we had a time machine. Which features which seemed like a good idea at the time have actually caused the development community hours of frustration? Which choices have caused confusion? What could we do differently next time?

Source: oredev

Saturday, 12 November 2016

Thirty months of Microservices. Stairway to heaven ... - Sander Hoogendoorn





Sander is an independent dad, mentor, trainer, software architect, programmer, speaker, and writer. He is a highly appreciated catalyst in the innovation of software development at his many international clients. 
Well known as the author of the best-selling book This Is Agile, Sander coaches organizations, projects and teams, has written books on UML and agile, and published over 250 articles in international magazines. He is an inspiring (keynote) speaker at many international conferences, and presents seminars and training courses on a variety of topics such as (beyond) agile, Scrum, Kanban, software estimation, software architecture, microservices, design patterns, modeling and UML, writing code, and testing.

Friday, 11 November 2016

Railway oriented programming: Error handling in functional languages - Scott Wlaschin


Many examples in functional programming assume that you are always on the "happy path". But to create a robust real world application you must deal with validation, logging, network and service errors, and other annoyances.
So, how do you handle all this in a clean functional way? This talk will provide a brief introduction to this topic, using a fun and easy-to-understand railway analogy.

Source: NDC

Thursday, 10 November 2016

Implementing message queue patterns using F# and actor model - Vagif Abilov



Vagif Abilov is a Russian/Norwegian software developer working for Miles in Oslo. He has several decades of programming experience that includes various programming languages, currently using mostly C# and F#. Vagif writes articles and speaks at user group sessions and conferences. He is a contributor to several open source projects and maintains a few of his own, such as Simple.OData.Client and MongOData.

Source: BuildStuff

Wednesday, 9 November 2016

Introduction to Git - Tim Berglund

  


An introduction to the basic principles of distributed source control, featuring demos of key Git commands, a recommended Git workflow, and just enough Git internals to get you started.


Source: oredev

Monday, 7 November 2016

Cloud Devops - Paul Stack and Lynn Langit


In this talk Paul and Lynn will 'show and tell' around Cloud Dev Ops via common use cases. They will compare and contrast the maturity of the deployment and management technologies for container-based web applications and for cloud-scale data warehouses.
Technologies to be covered are as follows: 1> Container-based Web Sites - AWS - ElasticBeanstalk w/Docker and ECS, Azure - PaaS WebSite w/Docker and ACS, GCP - Docker-based PaaS w/Kubernetes 2> Data Warehouses - AWS - Redshift, ETL Partners (Matillion), Visualization Partners (Yellow Fin] , GCP - BigQuery, Data Flow, Tableau - Azure - ETL patterns, SQL Azure Data Warehouse, and PowerBI You will walk away from this session with practical knowledge, patterns and tips for using these key cloud services as they work today.

Source: NDC

Sunday, 6 November 2016

Retrospective Anti-Patterns - Aino Vonge Corry





Anti-Patterns are like patterns, only more informative. With anti-patterns you will first see what patterns reoccur in "bad" retrospectives and then you will see how to avoid, or remedy, the situation.

Source: goto

Saturday, 5 November 2016

Life without objects - Osvaldas Grigas


Transitioning from OOP to functional style can be quite challenging, not least because OO programmers are used to thinking in nouns. Programming languages that use functions as primary means of abstraction force one to:

- design things in terms of verbs,
- find new ways of doing composition,
- rediscover polymorphism in a different light.

Fear not! What you have learned about good OO design can be applied to FP, in obvious and weird ways. Code examples will be presented in Clojure.

Source: buildstuff

Friday, 4 November 2016

Kanban Thinking - Karl Scotland


Karl Scotland introduces a process model for designing a kanban system, taking a systems thinking approach to improving flow, delivering value, and building capability. You will discover how to design a custom kanban system using techniques to study your team's current work and process, share a common understanding through visualisation, limit the work in process, sense how the system is performing with metrics, and learn how to evolve so your team can continually improve.

Source: Oredev

Thursday, 3 November 2016

Project Kudu, The Magic Behind Azure App Services’ Continuous Deployment - Emad Alashi


Microsoft Azure Web Apps have a fantastic feature of deploying from code repositories; GitHub, Dropbox, VisualStudio Online, ..and others.
You might already know this, but what you might not know is that this engine actually has a name: Project Kudu!As part of Microsoft's Open Source initiatives, Project Kudu is actually an Open Source project; making it available for custom scenarios and local deployments as well. In this session you will learn more about Project Kudu, how it really works behind the scenes, its main features, how to do custom deployments on Azure App Services, how to utilize it for your local environment, and what scenarios it perfectly fits.

Source: NDC

Wednesday, 2 November 2016

Strategic Design - Eric Evans


As software development leaders, we need to think more strategically. Some design decisions affect the trajectory of the whole project or even the organization. These decisions arise in early chartering and throughout development, and they are about much more than architecture. This talk will examine these issues through the lens of the Strategic Design principles of domain-driven design, which systematize a few critical practices some successful teams do intuitively.
It is common for skilled teams to deliver software they are not proud of, due to compromises with legacy designs. Others toil for years, producing a platform that is never used to good advantage. These are strategic failures. On the other hand, there are projects with a direct explanation of how the software contributes to business goals. There are projects where designers work with a realistic view of the context of their development within the larger system, allowing them to maintain design clarity and integrity. These are strategic successes. Winning strategy starts with the domain.
Two domain-driven design principles, ?Context Mapping? and ?Distilling the Core Domain?, help you see your strategic situation more clearly and approach strategic design decisions more systematically. These techniques require extensive interaction with domain experts as well as the leaders of the organization, in discussions broader than functional requirements. They sometimes lead to priorities quite different from our most comfortable notions.

Source: Oredev

Tuesday, 1 November 2016

Building Blocks of a Knowledge Work Culture - Doc Norton



Much of what we’ve learned about management and motivation isn’t necessarily wrong, it’s just inappropriate and ineffective for knowledge work. To create a truly impactful knowledge work environment, you need to use appropriate leadership styles and create an environment that allows people to achieve their highest potential. Doc takes a look at types of work, the management styles that work best for them, and the qualities necessary to create a high-performing knowledge work culture.

Monday, 31 October 2016

Rearchitect your code towards async/await - Daniel Marbach



The die is cast. Your business- and infrastructure logic will need to move gradually to asynchronous code. Changing large code-bases to async/await seems like a monumental effort. It doesn't have to be! In this talk, I show you a four-phased approach to evolving your code-base towards async/wait. In the identification phase, we classify the components which would benefit from async/await. In the exploration phase, we discover potential road blockers which might hinder the async/await adoption.
In the obstacle phase, we learn to redesign parts of the code to remove the previously identified road blockers. In the bring-it-together phase, we gradually move the components which benefit the most from async/await to a full asynchronous API. Small steps. No Big Bang. Join me on a journey towards async/await and learn to leverage the power of asynchronous code to embrace the cloud-first APIs of today and tomorrow.

Source: NDC

Sunday, 30 October 2016

Manage Yourself! - Jurgen Appelo


Manage Yourself!

Manage Yourself! is about concrete management advice for all workers. Practical things that people can do next Monday morning, in order to grow an organization that is fit and healthy. And not only managers, but everyone who is concerned about the organization. Because, management is too important to leave to the managers. The whole organization should feel responsible for a better organizational culture.

How can we measure team performance?
How can we pursue career paths?
How can we replace performance appraisals?
How can we motivate our ourselves?

Nowadays, all knowledge workers are expected to be “servant leaders” and “systems thinkers”. In this session, you will learn how you can do that concretely. As a result, you will have better management with fewer managers.

Source: Optional Conference

Saturday, 29 October 2016

Sherlock Homepage - A detective story about running large web services - Maarten Balliauw



The site was slow. CPU and memory usage everywhere! Some dead objects in the corner. Something terrible must have happened! We have some IIS logs. Some traces from a witness. But not enough to find out what was wrong.
In this session, we’ll see how effective telemetry, a profiler or two as well as a refresher of how IIS runs our ASP.NET web applications can help solve this server murder mystery.

Source: NDC

Friday, 28 October 2016

Promise to Not Use Promises: Observables in ES.next - Brian Holt



ES6’s native support for Promises landed just late enough for Brian Holt to realize that he should never use them. He’ll explain how Observables, a spec that forms the basis of RxJS and is in ongoing discussion to perhaps land in ES.next, made him see the light. Brian outlines what Observables are, how to use Observables in code today using RxJS, how Observables can totally eclipse the use of Promises, and what the state of the Observable spec is for native JavaScript. Participants will leave with the knowledge of a forthcoming tool they can add now to their toolbox.

Source: ABBDevDay

Thursday, 27 October 2016

Agile Leadership – A trip through 2.5 million years - Louise Elliott


What does human evolution teach us about how we should lead teams in the 21st century? This talk takes a journey covering the last 2.5 million years from a hunter and gather lifestyle to the creation of agriculture and through to the industrial revolution, in order to understand the influences which still affect us today. It asks questions such as “Why are 30% of Fortune 500 CEOs so tall?” and “Can you tell a person’s job just by looking at their face?”. It also delves into the different strategies which chimpanzees use to become the alpha male and considers whether any of them would be useful in the human world.

Source: NDC

Wednesday, 26 October 2016

Top 20 tools and tips that make me a better developer - Roy Osherove



In this session you will learn about the tools I use every day to speed up my work, to help me think better, to help me plan better and execute faster, to find errors faster, to automate easier and to be better at what I do. Bring a pen and paper - you'll need them!

Source: Oredev

Tuesday, 25 October 2016

Cross-Platform Desktop Apps with Electron - David Neal



Cross-Platform Desktop Apps with Electron - David NealWould you like to leverage your HTML, CSS, and JavaScript skills to build cross-platform desktop applications? Electron is an open source application shell created by GitHub, designed to make building great desktop applications easy.
You may have already experienced Electron using applications such as Atom, Slack, or Visual Studio Code. In this talk, you will learn its features, how to quickly get started, and tips from my experience building Electron applications.


Source: NDC

Monday, 24 October 2016

Metrics Driven Development - Sam Elamin


In this talk Sam Elamin will relate his real life experience working on a distributed system dealing with £100,000 worth of transactions every hour. Sam will cover monitoring and how to develop your features based on how your customers use your platform and, most importantly, business metrics.

Source: Dev Day

Sunday, 23 October 2016

Event Sourcing & Immutable infrastructure - Greg Young, James Nugent


--Immutable Infrastructure with Packer and Terraform
In this webcast we will look at the basics of using Packer to build machine images for a variety of clouds, and using Terraform to provision cloud resources, in order to declaritively manage infrastructure in an immutable fashion. We'll also look at common patterns for good factoring of infrastructure-as-code which allows application teams autonomy for their services, while retaining central operations control of shared infrastructure.

--Event Sourcing
Looking at mature domains it is odd that almost none have a concept of current state but instead are built off a set of facts that occurred; is your bank balance a column in a table? This is not by accident and there are many benefits to having this viewpoint of a system both from a business and a technological viewpoint. In this talk we will look at what cqrs (command and query responsibility segregation) and event sourcing are.

Source: BuildStuff

Friday, 21 October 2016

19 1/2 Things to Make You a Better Object Oriented Programmer - Greg Young



This session will introduce a series of things that will make you a better object oriented programmer and more importantly give you explanations on the thought processes behind the ideas.

Source: oredev

Thursday, 20 October 2016

Choosing a JavaScript Framework - Rob Eisenberg



In the last couple of years there has been an explosion in JavaScript frameworks. How is a developer or business to make a wise choice? What are the advantages, trade-offs and differences? In this talk we’ll compare and contrast six popular front-end frameworks: Angular 1, Angular 2, Polymer, React, Ember and Aurelia. We’ll look at the same “Hello World” example in each framework so we can see, side-by-side, the differences in development strategy and philosophy.
We’ll also discuss how these frameworks stack up against a set of both technical and non-technical key evaluators so that you can get beyond the hype and finally make a solid technical and business decision.

Source: NDC

Wednesday, 19 October 2016

Specification By Example - Gojko Adzic

The owner of this video has set domain restrictions. You can watch it here.

About Gojko Adzic

Gojko is a strategic software delivery consultant who works with ambitious teams to improve the quality of their software products and processes.

He specialises in Lean|Agile quality improvement, in particular Agile testing, Specification By Example and behaviour-driven development.

Gojko’s book Specification By Example was awarded the number two spot of the top Agile books for 2012 and won the Jolt Award for best book of 2012. In 2011, he was voted by peers as the most influential Agile testing professional and his blog won the UK Agile award for the best online publication in 2010.

Source: Assurity Consulting Vimeo



Tuesday, 18 October 2016

Practical Microservice security - Laura Bell


Moving away from complex monolithic architectures has a range of well documented benefits but also dramatically changes how we have to think about security. How can we make the most of these new approaches without introducing risk to our applications and organizations?
In this session we take a look at securing microservice architectures and discuss tools, techniques and considerations to achieve this. Based around real world examples and demonstrating both attacks and defence techniques, we will learn how to be bad to our systems in the name of being good.

Source: ndc vimeo

Monday, 17 October 2016

Security and Authorization in .NET Core World - Barry Dorrans



ASP.NET Core has presented us with the opportunity to improve our security store, throw away or improve on of the mistakes of the past. ASP.NET now has a new authorization stack and different ways to load balance cryptographic keys. This session will demonstrate the new features and walk you through building a flexible authorization system to help you secure your web apps.

Source: Channel9

Sunday, 16 October 2016

The Technical Debt Trap - Doc Norton



Technical Debt has become a catch-all phrase for any code that needs to be re-worked. Much like Refactoring has become a catch-all phrase for any activity that involves changing code.
These fundamental misunderstandings and comfortable yet mis-applied metaphors have resulted in a plethora of poor decisions. What is technical debt? What is not technical debt? Why should we care? What is the cost of misunderstanding? What do we do about it? Doc discusses the origins of the metaphor, what it means today, and how we properly identify and manage technical debt.

Source:  ndc video

Saturday, 15 October 2016

The Next Wave of Mobile Apps: TypeScript 2, Angular 2 + Ionic 2 - Ryan Salva




For users already familiar with Ionic and Apache Cordova, this intermediate to advanced level session will explore some of the new design patterns, development workflows and... yes, even quirks in the next generation of JavaScript frameworks. You'll learn how to bend the toolchain to your will to accomplish some truly amazing feats of code.

Source: channel9

Friday, 14 October 2016

Agile Metrics - Beyond burn up/down’s onto Metric Driven Coaching - Troy Magennis



How can metrics be used safely in coaching Agile teams? The classic Goldratt quote 'Tell me how you will measure me and I will tell you how I'll behave' signals the danger of using metrics to manage or motivate employees. This session shows and suggests approaches to Agile metrics that avoid the common pitfalls and shows some practical dashboards and the resulting chaos or calm they caused. This talk will show actual dashboards and metrics from actual industry engagements. It will explain how to safely capture and display these and how to teach an organization to see and understand its data. Be warned though, the techniques shown go beyond burndowns charts and cumulative flow diagrams.

Learn

  • The dangers of managing by metrics
  • Balanced approach to metric dashboards (less is more, but too little is disastrous)
  • Digital storytelling and patterns (examples of good and bad dashboards)
  • Coaching advice and dashboards
  • Visualizations of the edge – attention grabbing ideas for action
Source: video, description

Thursday, 13 October 2016

Build Real-Time Websites and Apps with SignalR - Rachel Appel



If you've ever wanted to build a highly responsive app that leverages a real-time communications library, then SignalR is for you! Real-time Web functionality is the ability to have the server push messaging aggressively to the client, rather than relying on the client to make multiple and frequent requests. SignalR is a set of ASP.NET server and client libraries that you can use to build real time, scalable, Web sites and apps. You can use SignalR in both enterprise and consumer apps, and across platforms. This session covers what you need to know to build a SignalR app that connects multiple clients instantaneously.

You will learn:


  • To use the SignalR libraries
  • About polling and real-time development techniques
  • About cross platform client connectivity

Wednesday, 12 October 2016

How to build .NET Microservices - Richard Banks



Thanks to organisations like Netflix, and the need to develop solutions that scale well in the cloud, microservices have become the hot new topic. Yet, for all the talk, there are few practical examples of how you actually build a microservice in .NET.
It's time to fix that littlle oversight as we show you how you can build a microservices based solution using .NET, and a number of open source tools (EventStore, RabbitMq and Redis to name a few).
You'll also get to understand the pros and cons of a microservices solution and consider how a microservices approach might impact how you and your team relate to your customers.

Source: ndc vimeo

Tuesday, 11 October 2016

Deep Dive into ASP.NET Core - Daniel Roth




In this talk we will dive deep into the guts of ASP.NET Core. We'll look at how the HTTP request pipeline is constructed and how HTTP features are exposed. We'll look at how ASP.NET Core hosting works and what best practices are for deploying and monitoring your application. We'll look at the guts of MVC and how it interacts with the core routing infrastructure.

You will learn:

  • About the ASP.NET Core HTTP pipeline
  • About ASP.NET Core hosting best practices
  • About ASP.NET Core MVC and its relationship to routing

Source: Channel9

Monday, 10 October 2016

Secrets of the Chrome Developer Tools - Patrick Dubroy

The Developer Tools built into Google Chrome provide powerful ways to understand, debug, and profile web applications. Most developers are familiar with its basic inspection and debugging tools, but some of its most valuable features, like the timeline and memory analysis tools, are lesser known. This talk will provide an overview of the Chrome dev tools and an in-depth demonstration of some of the lesser-known features.




Source: video, description

Sunday, 9 October 2016

Deploying Docker Containers on Windows Server 2016 - Ben Hall



Docker has changed the way we deploy applications onto Linux and ARM based systems. Windows Server 2016 introduces first class container support to the Windows Kernel.
In this session Ben will explore how Docker and Windows will work together, the impact it will have and how you can get started.
Key talking points will include:
- Deploying applications using Windows containers
- Managing Windows containers using tools from the Docker ecosystem
- Combining Linux and Windows containers
- Difference between Nano containers and Server Core containers
- Why Hyper-V isolation exists
- Windows Container Security Model
At the end attendees will understand how containers on Windows will work and the problems they’ll solve.

Source: ndc vimeo

Saturday, 8 October 2016

UX in an Agile Process - Janne Jul Jensen

Originally, the field of usability and interaction design was slow, cumbersome and costly. These were some of the reasons that it was not adopted very fast among practitioners. However, recent years a lot of the methods and techniques have been adapted to better fit the fast moving development processes that are predominant in software companies today. But what do you do when you can't include users because of NDAs? How do you handle the fierce security demands, that are part of your project? Does your customer really know their users, or do they only think they do? And when you have a deadline, how do you avoid UI slowing your progress? This talk is a case story of how UX was included in the agile development process that resulted in the first Danish mobile bank app: Danske Banks mobile banking app.



 Source: video, description

Friday, 7 October 2016

Software that Fits in Your Head - Dan North

Software gets complicated fast. Most of good architecture and design practise is about trying to slow the rate at which software gets complicated. You can't stop it, it's a form of entropy. You can only slow it down and do your level best to stay on top of things.

One way to manage the mess is to maximise the likelihood that everyone knows what's going on in the codebase. This requires two things: consistency and replaceability.

Consistency implies you can make reasonable assumptions about unfamiliar parts of the application. Replaceability means you can kill code easily and replace it with something better.

Dan North argues that code should either be new enough that someone remembers writing it, or well-enough established that everyone knows how it works. It's code in that awkward middle stage, between brand new and part-of-the-furniture, that gets forgotten about and starts to smell.
If code is going to die it should die quickly. If it is going to stick around it should be stable.

In this talk, Dan describes a model for thinking about the age of code and argues for replaceability as a first class concern. He also discovers that if you optimise for both replaceability and consistency you can end up with something that looks a lot like microservices.




Source: video, description.

Thursday, 6 October 2016

Debugging Tips and Tricks for .NET Developers with Visual Studio - Kaycee Anderson


"Every software developer has the need to debug problems in code, but we are rarely taught how to use the debugging tools available to us. Come to this demo-driven session where we’ll learn how to supercharge our debugging to find bugs faster. We’ll tour most of the debugger, throwing in tips and tricks as we go along, and show a couple new features coming in the next release. Whatever your experience level we guarantee you’ll learn something new." from channel9.msdn.com

Wednesday, 5 October 2016

Continuous delivering continuous delivery - Kim van Wilgen

In her role as CIO at the well-known Dutch insurance company Klaverblad Verzekeringen, Kim van Wilgen is responsible for all software development and operations. Although a nerd at heart, she also has over a decade of experience in product development and comparable managerial roles on the other side: the business. She can still speak just enough of the language of the product owners and the users to understand the gap we quite frequently need to bridge. Kim van Wilgen is passionate about topics such as agile, Kanban, DevOps and continuous delivery. and the management of the cultural, organizational, team and technological changes associated with these approaches. from Build Stuff

Monday, 3 October 2016

How to become Agile without Scrum or Kanban - Kjell Ljøstad

This is NOT a talk about Scrum or Kanban. The Agile Manifesto is all about communication, interaction, collaboration and building trust. Yet when most companies decide to go agile, they focus on implementing some rigid process that they don't yet fully understand, and they have a hard time getting it to work. We go back to the core of the Agile ideology. We will talk about how you can use relational skills to improve communication, get team members engaged and build trust.
Agile initiatives tend to become a matter limited to the developers, and it is often hard to engage other parts of the organisation?. In this workshop you will learn what make teams work efficiently and the basics of how you can get the whole organisation to cooperate better. By building relations and trust between people, working on how they communicate and how they interact with each other, you will build the foundation of a truly agile organization.
Takeaways:
Most of us have experiences from both good and bad teams. It is often hard to point out why things turned out the way they did. After this talk you will know what make teams more efficient and increase your awareness of the things that make your team dysfunctional. - Kjell Ljøstad

Sunday, 2 October 2016

Introduction to NoSQL - Martin Fowler



"Martin gives a rapid introduction to NoSQL databases: where they came from, the nature of the data models they use, and the different way you have to think about consistency. From this he outlines what kinds of circumstances you should consider using them, why they will not make relational databases obsolete, and the important consequence of polyglot persistence."

Saturday, 1 October 2016

TypeScript for C# Developers - Chris Klug

Over the last few years, JavaScript has solidified itself as the universal language of the Web. All attempts to change this, like Flash and Silverlight, have failed. So you might as well accept that if you are going to be working with anything related to the internet, it is highly likely that you will be using JavaScript; at least for the foreseeable future. And even if you ignore the browser and stay on the server, projects like Node.js is gaining popularity and putting JavaScript there as well. Unfortunately, JavaScript is not the easiest language to learn and understand. It is full of awesome features and some really bad ones. And being as flexible as it is, tooling has a hard time keeping up. And this is where TypeScript comes in. TypeScript is a superset to JavaScript that tries to solve a lot of these problems, and make the code more structured, and less error prone. And it also offers tooling support in a way that JavaScript just can't. So why not join this session and get an introduction to TypeScript, and see what it can do for you? - Chris Klug

Thursday, 29 September 2016

The Future of C# - Dustin Campbell, Mads Torgersen

Since Roslyn shipped last year we’ve been hard at work building on it to improve tooling, add new language features and enhance Roslyn itself. In this session Dustin and Mads will play with fire, showing early versions of new C# 7 language features such as tuples and pattern matching, new editor features like code style and source generators, and much more. - Dustin Campbell, Mads Torgersen

Wednesday, 28 September 2016

Life As A Developer: My Code Does Not Work Because I Am A Victim Of Complex Societal Factors That Are Beyond My Control…. – James Mickens

"What are the best practices for shipping high-quality software?" This question is an example of a question that I will not answer in my talk. Instead, I will describe why any software project that contains more than 10 lines of code is guaranteed to fail. Using my fragmentary knowledge of the laws of thermodynamics, I will explain why code is like a proton that must ultimately turn into a crystal or, uh, whatever it is that thermodynamics says will happen. I will demonstrate how unit tests, functional programming, and UML diagrams fail to address the primary source of software failure (namely, that software is an inherently bad idea because our brains evolved to hunt giant sloths with primitive stone tools, and MongoDB only partially resembles a giant sloth).
I will conclude the talk by luring a group of agile programming experts into a large cardboard box using a collection of buzzwords like "evolutionary development" and "cross-functional team;" once captured, they will be forced to implement obscene, poorly-specified COBOL algorithms as I laugh maniacally and disable my compiler warnings. – James Mickens


Tuesday, 27 September 2016

The Idiot’s Guide to Quashing Microservices - Hani Suleiman

So your boss, annoying coworker, or random stranger has cornered you and started screaming at you that micro services are the answer to every problem you’ve had (and many you’ve never had).

You feel scared, you feel angry, and you’re not sure of what to do next. Do you jump in enthusiastically, or do you risk looking like a grinch by saying no?

In this talk, we’ll explore options between those two extremes. We’ll arm you with intelligent rebuttals and holes against microservices pitches that nobody puts on the brochures. The financial industry often has interesting restrictions and requirements, and a naive approach to microservices is bound to run afoul of all of these without sufficient preparation. - Hani Suleiman

Monday, 26 September 2016

Making Hacking Childs Play - Troy Hunt

How does it keep happening? I mean why are websites so consistently hacked? Is it the work of sophisticated cyber-villains operating from underground lairs? As it turns out, many of today’s online attacks are mounted by kids – legally children – who simply have time, patience and access to Google.
In this session we’re going to look at and execute a heap of online attacks with tools that even kids can use. You’ll learn just how easy it is to mount these attacks and most importantly, what it is you need to do to keep your apps secure not just from mischievous kids, but from cyber-criminals and even nation state actors.
This talk is scary, entertaining and will make you distrusting of any kid with a PC. - Troy Hunt

Sunday, 25 September 2016

Domain-Driven Design: The Good Parts - Jimmy Bogard

"The greenfield project started out so promising. Instead of devolving into big ball of mud, the team decided to apply domain-driven design principles. Ubiquitous language, proper boundaries, encapsulation, it all made sense.
But along the way, something went completely and utterly wrong. It started with arguments on the proper way of implementing aggregates and entities. Arguments began over project and folder structure. Someone read a blog post that repositories are evil, and ORMs the devil incarnate. Another read that relational databases are last century, we need to store everything as a stream of events. Then came the actor model and frameworks that sounded like someone clearing their throat. Instead of a nice, clean architecture, the team chased the next new approach without ever actually shipping anything.
Beyond the endless technical arguments it causes, domain-driven design can actually produce great software. We have to look past the hype into the true value of DDD, what it can bring to our organizations and how it can enable us to build quality systems. With the advent of microservices, DDD is more important than ever - but only if we can get to the good parts." - Jimmy Bogard


Saturday, 24 September 2016

Functional architecture - The pits of success - Mark Seemann

Object-oriented architects and developers have, over the years, learned many hard lessons about successfully designing systems with object-oriented programming. This has led to a plethora of ‘best practices’ that are painfully passed on from older to younger generations via books, lectures, consulting, blog posts, etc.
Many of these ‘best practices’ must be explicitly taught, because they don’t evolve naturally from object-oriented programming. Surprisingly, many of these hard-won ‘best practices’ fall naturally into place when applying functional programming. Instead of deliberate design, functional programming forms pits of success where you naturally fall into the same ‘best practices’ that you have to deliberately work for in object-oriented programming. In this session, you’ll learn about a handful of such ‘best practices’, and how functional programming automatically lead you there, without your explicit effort.

Friday, 23 September 2016

Keynote NDC Sydney 2016: “If I knew then what I know now…” – Scott Hanselman

I’ve been coding for money for 25 years. I recently met a programmer who’s been coding for over 50. They asked me how they could become a web developer. Here’s what I told them.  – Scott Hanselman


Thursday, 22 September 2016

Elixir Is Neat But What Can You Actually Do With It? - Rob Conery

Working with Elixir is intoxicating. The syntax is clean, pattern matching is thrilling, and the power of the Erlang VM underneath is mind-blowing. But what can you actually build with it? What patterns do you use… what tools? Are Phoenix and Ecto my only choices for web and data frameworks?
In this talk Rob Conery will share his experience migrating a Ruby on Rails application to Elixir, and the choices he faced along the way. We’ll dive into Agents, Supervision Trees, JSONB and potential life on Mars as we figure out the best way to structure an application in Elixir that works great both now and into the future.