As developers looking to write better code, we spend a lot of time talking about hexagonal architecture, DDD, event sourcing, microservices, the list goes on and on.

But doesn’t it seem like every time we try some new high level design idea, it’s always the next one that’s going to solve all of our problems?

“If only we had used CQRS on that last project, our code would’ve been so much more maintainable!”

What if we’re worrying about the wrong thing? What if it’s not the architecture that’s the problem, but the little lines of code on our screen that we work with every day?

There’s a symmetry between low level design and high level architecture, but you have to get the low level design right first. This talk is about zooming in the microscope a little bit and focusing on writing great code, one line at a time.

As a developer, you have probably thought, “I wonder what it would be like to start my own startup…“, and then you romanticize the idea in every way (#famous #cashmoney #imtheboss). Mat Silva has actually launched a startup and will talk through the realities of launching & running a funded startup. You will hear his startup’s story, get first hand insight from his success & failures and ultimately get a better understanding of what it takes to actually launch a technology startup.

We’re going to very distant lands. With Engine and Compose, Registry and Machine, the fun will never end, it’s Docker Time!

The Docker platform allows you to implement lightweight containers to run small pieces of functionality in an isolated manner inside of either a virtual machine (e.g. AWS, OpenStack, VirtualBox) or on non-virtualized physical hardware (e.g. a datacenter, directly on your fancy laptop).

Getting started running containers with Docker is relatively simple and takes just a few steps. Anyone who knows how to open the terminal and run a few commands can have a container up and running in a matter of minutes. Like with most new technology platforms, the barrier to entry for most folks seems to be figuring out how Docker can be implemented in a way that solves more problems than it creates.

We’ll go over some practical examples of implementing the Docker platform starting with container building and use in local development, through the process of continuous integration and delivery, to actually deploying containers in an intelligent way in production.

You should be able to walk away with an idea of how Docker might be able to help in your day to day technological adventures.

From in-house product teams to remote freelance; from greenfield to legacy, many of us find ourselves on projects that require us to work with team members across disciplines and clients in different domains. How do we work effectively on these teams? This talk, tag-teamed by a Developer and a Product Designer, will showcase some methods that can improve the way you work collaboratively with your team. When working on a cross-disciplinary team, it’s important to know how and when to pair up, delegate tasks, and organize phases of the project from discovery to deployment. We’ll show you how to get answers for the questions you have. We’ll give you the language you need to understand all those pesky design terms, and you’ll be given examples of effective dev/design pairing, facilitating effective client meetings, and managing sprints.

One of the first words we learn as children is “NO”. Yet, somewhere between learning our A-B-Cs and launching our careers as technologists, we forget about the power that NO holds. “NO” is one word that should be prominently featured in every technologist’s lexicon. As technologists, we’re fortunate to possess skills that are in high demand. Demand is often so high that we’re mistaken for bottomless wells of time and energy that can be continuously tapped. There comes a point where we - and our leaders, advocating on our behalf - must unleash our power of saying NO: NO to that last tweak, NO to that final copy change, or NO to the brand new feature that just fell out of the sky and on to our backlog.

Jon was asked to build a fuzzytext search interface for information stored in the SEC’s massive Edgar database which holds all of the electronic documents filed with the SEC. By leveraging managed ElasticSearch, S3 for document storage, and the asynchronous job processing power of AWS Lambda he was able to build a solution that required absolutely no ongoing server maintenance for his client.

In this talk, Jon will explain how he was able to:

• Parse gigabytes of info without IP activity restrictions
• Provide an easy way to scale or disable the application
• Continuously monitor parsing activity and application health

You will learn about the different services utilized with their strengths and weaknesses as well as alternative services like Iron.io which allows you to write code in many different languages. He’ll also talk about different ways async processing can be applied to other situations such as managing contact forms for static websites as FormKeep does.

No one writes code just to look at it in dev. The goal of software is to deploy it to a production environment and get it in front of users. Users want stability, reliability, and scalability.

How do we get our software and tools to a level where they can provide those features? How do you know that you have met those requirements and that the system is ready for a production deployment? What do stability, reliability and scalability look like as features? Does that new library, tool or framework meet those requirements?

It is not enough for a tool to meet a software requirement, you must also think about how putting it into production will affect the maintenance and support of the entire system. The business must be willing to invest in making it production ready and the operations staff must be able to provide ongoing support.

In this talk you’ll be walked through the questions you need to ask in order to ensure production readiness and shown what techniques to use to develop production ready systems.

“Functional” programming languages - such as Scala, Elixir, Clojure, and Haskell - are rapidly gaining in popularity. Even what many would consider “traditional” programming languages - such as Java, Ruby, and JavaScript - are adding “functional” aspects. But what does it mean for a language or program to be functional? And why are people claiming that it will help build better, cleaner code? We’ll explore the foundations of the functional paradigm, and how you can use it in your own development to help improve software quality. This applies even if you are coming from an imperative or object-oriented background, or you are using a language which is not normally considered “functional”.

This talk does not presuppose any knowledge of any of the languages listed.