We’ve all seen them on the corner of our local software development neighborhoods: FP purists, shamelessly peddling scalaz to unsuspecting developers. Lured in by promises of Free Monoids, Semigroups, and Endofunctors these developers soon seem lost in throes of ecstatic coding.
To the skeptical and stubbornly practical among us, the above might ring a little true – especially if read in Rod Serling’s voice. Images of gibbering horrors lurking in the depths of mathematical perfection swim before our eyes.
But what if there is true value in the world of scalaz? What if it is possible to use these tools for good (and a little bit of evil – it’s fun to use learning for evil!) and profit… Without getting hopelessly lost in the opium dens of FP?
In this talk we will look at some of the “gateway drugs” of scalaz: Validation, NonEmptyList, \/, Monad Transformers, and more. How do they work from a practical standpoint? What is their value for real world applications? Can we use them without an advanced Maths PhD? And just how fun is it to *really* code with these tools?
Brendan’s talk is now available on the Chariot Solutions site.
You’re ready to go with all the best Agile practices: you’ll develop incrementally and iteratively, you’ll have sprints and retrospectives, and you can’t wait to tell your clients about your velocity and show them your burndown charts. But all of your prospective clients are telling you they want firm quotes, and contracts with detailed specifications and delivery dates. Clients almost always start with a preference for these types of traditional contracts. Such contracts provide them with a sense of security and confidence that they will get what they want.
How do you convince them a traditional contract is actually riskier than they think, and persuade them to instead sign an Agile (time and materials) contract? This is the most significant challenge facing consultants who want to follow Agile practices. In this talk we’ll discuss:
Michael’s talk is now available on the Chariot Solutions site.
Angular 2 is built for huge web applications that stand the test of time. To accomplish this, Angular 2 utilizes the latest and greatest web technologies like ES6 modules/classes and Web Components. Come get a preview of what this looks like with Egghead.io instructor Kent C. Dodds as he live codes an application using the pre-release alpha version of Angular 2.
Kent’s talk is now available on the Chariot Solutions site.
Rarely do we have a chance to rewrite an application from scratch with the newest techniques. Generally we must work within our existing architectures evolving and refactoring years of code. This can make it seem reactive programming either can’t be introduced or doesn’t play a role.
Netflix has been doing reactive programming with RxJava in production for several years and only recently embarked on “greenfield” development efforts that are fully async. This talk will leverage the experience of introducing reactive programming into existing imperative, blocking codebases to demonstrate how it can be done and when it can make sense to do so. Not all benefits of reactive programming can be obtained without a greenfield, fully async architecture, but many can. Subjects to be covered will include the mental shift from imperative to declarative, working with blocking IO such as JDBC and RPC, service composition, debugging and unit testing.
Ben’s talk is now available on the Chariot Solutions site. View:
We explain optimization techniques used to set three world speed records. Using a combination of code generation and hardware specific optimizations, we achieved a 20x speedup over hand tuned assembly. These techniques depend on two things 1) exploiting domain specific dependencies that are too specialized for a compiler to detect and too tedious for a programmer to exploit, and 2) knowing how to profile the operations being performed by your CPU. These optimizations can be successfully applied to CPU bound code in any compiled language for a wide range of analytics problems.
David’s talk is now available on the Chariot Solutions website.
Today’s applications are distributed systems – they’ve outgrown single servers, and “scale-out” architectures have become the norm. But building new distributed systems, especially those that need to explicitly manage data, is still brittle and difficult, especially in failure and maintenance scenarios.
In this talk, Benjamin Hindman (one of the original creators of the Apache Mesos project) will discuss Apache Mesos and how it can be used to more easily build and run distributed systems. In particular, he’ll focus on the Mesos API for building a distributed system, and discuss how the primitives provided by Mesos can make it easier to build new stateful services and frameworks such as key value stores, message queues, message brokers, and distributed file systems.
Ben’s talk is now available on the Chariot Solutions site.
In this talk, Ash Furrow, author and iOS engineer at Artsy, presents the current state of Apple’s new programming language: Swift. He’ll begin with a description of why Swift was needed – what problems existed with Objective-C and how does Swift address them? Speaking from experience of developing a production application using Swift, Ash will discuss Swift’s readiness from both technical and business standpoints.
Ash’s talk is now available on the Chariot Solutions site.
Writing multithreaded code is hard—even harder than most people realise.
The good news is that there are other approaches, such as Functional Programming, Communicating Sequential Processes, Actors, and so on, which make it much easier.
This talk will start by looking at some of the less well-understood problems with multi-threaded programming—everyone knows about deadlock and livelock, but do you know what the memory model says about concurrent code, and why that makes it even harder to write than you thought?
We’ll then move on to look at the alternatives, and see why they avoid these problems. We’ll concentrate on Actors, and see how they not only solve the problems with Threads and Locks, but also make your code clearer and more robust.
Clojure makes highly functional programming fun… until it isn’t. Runtime type errors from a function that was returned from another function? I’m longing for Scala’s compiler errors! Nested maps of data make testing easier… until “Wait, what’s in there again?” What I want is a little bit of typing in strategic places: enter Prismatic’s Schema library. What look like types are really contracts. They’re even more powerful than types: they verify values as well as shapes. Exercised in generative tests, these contracts satisfy my type cravings without the pain of satisfying a compiler. There are limitations; schemas can’t express relationships between input and output types… or can they? Schemas don’t express parameterized types… or can they? Explore the potential of contracts as the best-yet compromise between types and tests. No Clojure experience (or interest) needed.
Jessica’s talk is now available on the Chariot Solutions site.
The goal of core.async is to decouple producers and consumers of information in software, without dictating specific thread or blocking semantics, and without introducing callback hell. Also, to do all of this as a library, portable anywhere you can run a dialect of Clojure.
core.async builds upon the work done with Communicating Sequential Processes, and provides:
What We Will Cover
In this talk, we will cover the design of core.async, and then move directly to exploring core.async’s capabilities:
goblocks to invert control, achieving async without threads
Finally, we will assemble these primitives into substantial working programs, building toward the Holy Grail of async: substantial UI application development in the browser, with no callbacks in sight.
Stuart’s talk is now available on the Chariot Solutions site.
When your top talent gets a call from your competitor down the street offering a 10% bump in salary, will they stay or jump? Is money everything? What can else can you offer them so that they will stay with you? There are no absolutes, but there are companies with low turn-over and the things they pay attention to tend to be quite different from what the companies that have retention issues pay attention to.
Come learn what else you can be offering your employees. Tom Devane (Workplace Dynamics) will lead a panel of industry experts who have figured out the secret to retaining their top talent. The panel includes representatives from the small startup to the large enterprise. Hear from Rick Nucci (Guru/Dell Boomi), Mike Rappaport (Chariot Solutions), Beth Arnholdt (Comcast).
Bluetooth Smart, or Bluetooth Low Energy devices are everywhere. We’ll look at how to discover, connect to, and control these devices with software. You’ll learn how Bluetooth LE works and understand profiles, services, and characteristics. I’ll demonstrate writing Android and iOS Bluetooth apps using Apache Cordova.
Don’s talk is now available on the Chariot Solutions site.
Modern, cloud-native applications typically use a microservices architecture in conjunction with NoSQL and/or sharded relational databases. However, in order to successfully use this approach you need to solve some distributed data management problems including how to maintain consistency between multiple databases without using 2PC. In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Separation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.
Chris’ talk is now available on the Chariot Solutions site.
Fast becoming a hot topic in the world of Reactive JVM applications is CQRS/ES (Command Query Responsibility Segregation and Event Sourcing). These design patterns, while not new, present a fresh way to reason about application design that is a natural fit for distributed computing.
This talk will explain the rationale behind CQRS/ES, how it fits the Reactive paradigm and the advantages regarding both the technology and business level. We will also discuss the implications of consistency models and how this approach affects Domain Driven Design.
Duncan’s talk is now available on the Chariot Solutions site.
Netflix has a complex micro-services architecture which is run in an active-active manner from multiple geographies on top of AWS. Application deployment and management is a very important aspect of running services in this manner at scale. We have developed Titan to make cluster management, application deployments and process supervision much more robust and efficient in terms of cpu/memory utilization across all of our servers in different geographies.
Titan is built on top of Apache Mesos for scheduling processes of applications on top of AWS EC2. In this talk we will talk about the design of our Mesos framework and the scheduler. We will focus on the following aspects of the scheduler – Bin packing algorithms, Scaling in and out of clusters, fault tolerance of processes via reconciliation and processing life cycle events, multi-geography/cross data center redundancy.
Diptanu’s talk is now available on the Chariot Solutions site.
Allen’s talk is now available on the Chariot Solutions site.
applications. In this talk, Tom will take you on a tour of the highlights of this battle-tested framework.
Topics covered include:
Tom’s talk is now available on the Chariot Solutions site.
If things go to plan, Dave Thomas will contend that we are looking at emerging technology wrongly. By definition, newer will be worse than older, at least in the short term. And yet we jump like lemmings off the bright and shiny cliff. So how do we find a balance?
Of course, things never go to plan.
Dave’s talk is now available on the Chariot Solutions site.
Datalog is a deductive query system combining a database of facts with a set of rules for deriving new facts from existing facts and other rules. Datalog has been a signature feature of Datomic since day one, and the 2015 releases of Datomic add additional expressiveness for hierarchical selection, disjunction, and negation. In this talk, we will cover the basics of Datomic Datalog, and then dive into the latest enhancements, both in the core language and in how Datalog fits into application code.
Datalog queries have the expressive power of SQL + recursion, and so are a good fit for systems that want “the power of SQL” but more flexibility. Perhaps more importantly, Datomic’s universal entity/attribute/value (EAV) schema has a one-to-one mapping with the object/method/argument shape of many programming languages. This allows a frictionless mapping from Datalog to application code, versus e.g. the impedance mismatch of object-relational mapping (ORM).
In this talk you will learn the basics of Datomic Datalog:
as well as some more recent enhancements:
Stuart’s talk is now available on the Chariot Solutions site.
In order to understand something, whether it be user behavior or software infrastructure, we must understand how it moves and changes with time. Unfortunately most of the tools of our trade offer little help in this regard. Packet switchers move data through our networks and relational databases hold onto account information. But what helps us understand the nature of this network traffic? Which services are talking to one another and how does this change during failure conditions or a deploy? What helps us understand how user behavior changes over time? And which features provoked these changes?
This talk will help prepare you to tackle these problems at a range of scales. We investigate not only existing tools, but the methods you can apply to build your own–whatever it takes to support a strong mental model of how your data is changing over time.
Dietrich’s talk is now available on the Chariot Solutions site.
Performance tuning is a methodical and an iterative process. It is imperative to have a performance plan coexist with a product development plan. A performance plan not only serves to document the requirements but also feeds into designing the performance experiments and helps in providing a clear understanding of the performance infrastructural needs.
As a JVM/GC performance engineer – I always ask pertinent questions such as – what are performance expectations of the product by the stakeholders? what are the important metrics?, what are the tuning goals?, etc. and then I discuss tradeoffs and finally establish tuning goals.
During this session, I will discuss these questions, tradeoffs and goals and I will also talk about my experience with three garbage collectors in OpenJDK’s HotSpot JVM – Parallel Old, CMS and G1 and compare and contrast them.
Monica’s talk is now available on the Chariot Solutions site.
Organizations will never realize the full potential of emerging technologies until they change their culture to one that learns fast through experimentation. To do this, many long held management beliefs and practices must be retired and replaced by approaches that allow knowledge workers to deliver better outcomes for all users of technology. In this session, Joanne will present principles, stories and practical suggestions on how to build a successful organizational culture that supports experimentation and learning with the goal to delivering better value for customers.
Marketing for a developer focused company, tends to work pretty differently from other fields. Designing eye catching newsletters, ads and other social media of your product doesn’t fly…not even a little bit. Developers are problem solvers and operate in focused communities that let them share knowledge. We need to engage with them in these communities.
Its not enough to just have docs, sample apps and fast support. If you want to bring developers to your product and see how to they interact with it, Evangelism is a necessary part of the equation. In this talk we will walk through key aspects of Evangelism and different strategies SendGrid has used and currently uses to reach these developers and turn them into friends who become customers.
Join Kunal Batra, a team lead on SendGrid’s developer relations team as he walks through the role of a Developer Evangelist and shares data and stories he’s collected from his over 2+ years of being a Evangelist at SendGrid.
Languages like Scala are making it easier to implement systems with distributed domains and distributed computation. Deployment, monitoring and operation of such systems is often neglected, left to the last moment. Jan will show how architect and implement your system with DevOps in mind right from the start.
You will see the details of a cluster-sharded domain in an Akka cluster, and a distributed computation in Spark, with REST APIs and mobile and wearable clients, running in a large number of Docker containers, with management from Marathon.
Come to Jan’s talk to find out about the challenges of designing and running such systems; you do not need to be an expert, or even have heard about the technologies Jan will show, to walk away with an appreciation of designing and running distributed systems.
Jan’s talk is now available on the Chariot Solutions site.
Over the past ten years, software development teams using Agile approaches to work have adopted retrospective meetings as a critical practice for learning and continuous improvement. To the extent that practitioners say, “If you’re not holding iteration retrospectives, you’re not doing Agile.”
Agile retrospectives at the end of each iteration or work increment set aside time for the team to examine feedback from current conditions and develop targeted tactics to keep the project on track. Many practitioners experience retrospectives as a great means for detecting good, poor, and missing practices; as a handle to make tacit knowledge about effective practices explicit; and to define improvement actions in order to deal with ineffective or inefficient technical, process, and teamwork practices.
However, too many teams and practitioners don’t reap the benefits that effective retrospective meetings can provide. Too many retrospective meetings receive cursory or inadequate facilitation. Too many retrospective meetings are held to “check the box” on the project management template, rather than to focus on real improvements. For too many teams, the action plans coming out of retrospectives are never implemented or revisited. Too many teams seek to shift blame and responsibility for action through the retrospective. In too many organizations, retrospective meetings don’t deliver the promised return on time invested (ROTI).
In this session, you’ll learn how to get the most from your retrospective practices. Diana Larsen, co-author of Agile Retrospectives: Making Good Teams Great, will introduce you to a simple framework for getting better outcomes from retrospective meetings, suggest ways to maintain the relevance of improvement to the work of your team, and provide tips and pointers to get great returns from the time your teams devote to every meeting.
Diana’s talk is now available on the Chariot Solutions site.
Mobile app development is a growing field with plenty of promise. It used to be that hybrid mobile apps weren’t ready for prime time — they were slow and unattractive. Then, along came AngularJS, which changed the way developers built apps for the web. Ionic, built on top of AngularJS, has dramatically changed the way developers build mobile apps. It’s open source, easy to use, beautiful, and ready to perform. In this talk, learn more about Ionic and its components, build a sample app, and explore the suite of tools and services Ionic provides for hybrid mobile app development.
Mike’s talk is now available on the Chariot Solutions site.
Apple has introduced “a better language” for iOS developers. But what options do we have for Android? Surely Kotlin should be under consideration! Android Studio is now based on Intellij Idea, the “native” environment for Kotlin.
Kotlin is a modern language for industry. It can help you reduce the amount of code you write for Android applications and at the same time make it readable and more maintainable.
In this session we are going to talk a bit why JetBrains sees the potential in Kotlin comparing to other JVM languages. Then we’ll see how certain language constructs can be used to make Android more enjoyable. Also we’ll look at a DSL for type-safe dynamic layouts and a simple extension plugin that helps to avoid writing ‘findViewById()’ all the time.
Svetlana’s talk is now available on the Chariot Solutions site.
For Java programmers, looping over a collection is the time-honored
way of processing data. Now, from Java 8 onwards, we will instead be
writing stream programs – more concise, more expressive, and more
maintainable. But how fast will they be? To understand the factors
that control stream performance, we need to look at how streams begin
and end as well as the work that they do along the way. And to make
things more complicated still, we have to decide when to use the
built-in parallelization support offered by streams. In this talk
we’ll disentangle these problems and create guidelines for getting the
best performance from Java 8 streams.
Maurice’s talk is now available on the Chariot Solutions site.
Linux containers provide the ability to reliably deploy 1000s of application instances in seconds, but how do we manage it all? The answer is CoreOS and Kubernetes. This talk will help attendees wrap their minds around complex topics such as distributed configuration management, service discovery, and application scheduling at scale.
Diversity in IT is not only good to create better teams, it is actually an economic necessity for companies. The Labor Department predicts there will be 1 million new, unfilled jobs in the tech industry by 2020.
With women and minorities making up a small percentage of the IT workforce and their numbers increasing in the general workforce, it makes sense to attract these groups to our field. But,we have not been successful in the past 40 years in creating this pipeline of candidates through traditional methods so what do we need to do differently.
Join our panelists who are part of a growing movement of non-profits working to change the discussion among women and minorities to learn more about their programs, what lessons they are learning about working with these groups, how they are helping to teach organizations to create diverse talent and potentially, how you can help solve this issue.
Massively concurrent systems are the future, and shared data mutability is the obstacle to getting there. Where does that leave imperative languages like Java, that depend on mutation? Java 8 squares the circle with the Collectors API, which manages concurrent access to non-threadsafe mutable collections, giving the developer parallelism “for free”. Sometimes you need to change the way you think about a problem, but often all you need to do is follow a few simple rules, and your code too can be Parallel-Ready.
Maurice’s talk is now available on the Chariot Solutions site.
The internet has moved a long way beyond the command line. Nowdays, it connects everything from our cars to our toothbrushes, door locks, and keychains. It’s no longer possible to think about software without considering the hardware on which it runs, the sensors and actuators that are its nerves and muscles, the form in which it’s encased, and the physical behaviors of the people and devices involved. Open source hardware and digital fabrication tools are enabling a wider audience to engage in building all aspects of interactive technologies, regardless of their backgrounds.
In this talk, I’ll present an overview of some of the tools of physical computing and discuss how and by whom they’re being used to create new connected devices.
Tom’s talk is now available on the Chariot Solutions site.
What happens if you take everything that is happening in your company—every click, every database change, every application log—and make it all available as a real-time stream of well structured data?
I will discuss the experience at LinkedIn and elsewhere moving from batch-oriented ETL to real-time streams using Apache Kafka. I’ll talk about how the design and implementation of Kafka was driven by this goal of acting as a real-time platform for event data. I will cover some of the challenges of scaling Kafka to hundreds of billions of events per day at Linkedin, supporting thousands of engineers, applications, and data systems in a self-service fashion.
I will describe how real-time streams can become the source of ETL into Hadoop or a relational data warehouse, and how real-time data can supplement the role of batch-oriented analytics in Hadoop or a traditional data warehouse.
I will also describe how applications and stream processing systems such as Storm, Spark, or Samza can make use of these feeds for sophisticated real-time data processing as events occur.
Jay’s talk is now available on the Chariot Solutions site.
React changed how we think about developing user interfaces. In this talk I’ll cover fundamental shifts in thinking presented by React and why they’re important.
Keeping a multi-faceted system running is hard work. It’s even harder when you have to deal with the day to day nonsense that happens on the web. Gathering the data you need to drive your business is also a tricky game. It is made even more complicated by all of the bots running around messing up the place. And the attacks. Oh the attacks. Every day all day with the attacks…
It’s not enough to just run your systems. The volume of robotic traffic your system deals with on a daily basis may surprise you. This traffic distorts your numbers, steals your data, and can even cause downtime. You can’t ignore it any longer.
Join Aaron as he explores ways to identify and deal with bad robots. He will show you what to look for, how to sort good bots from bad, and what to do with the information once you have it. It will help you deal more efficiently with scrapers, crawlers, scanners, fraudsters, and general malicious activity on your systems and gain some much needed confidence and visibility into the types of traffic you actually get on a day to day basis.
Aaron’s talk is now available on the Chariot Solutions site.
Developing for the web platform has historically been a slow, painful, fragile experience. You write code in multiple different languages, work with undocumented APIs, and are forced to implement things twice to have them work on both client and server. Lastly, you had better be the meticulous sort, because a single typo will bring down your site: at runtime, in production!
This talk will show off Scala.js and how you can get started using it. Starting from nothing, we will build a number of small Scala.js applications, which will hopefully demonstrate this promise. No Scala experience required.
Haoyi’s talk is now available on the Chariot Solutions site.
Social engineers use a dangerous combination of technology and old-fashioned con artistry to infiltrate organizations every day. In this talk we’ll walk through the social engineering process including research, target selection, attack selection, and attack execution. Learn to see the world through the eyes of a social engineer and prevent your company from being a victim.
This talk presents Apache Spark, Spark Streaming, Apache Kafka, Apache Cassandra and Akka as supporting Lambda architecture in the context of a fault tolerant, streaming big data pipeline. We will walk through the Fault Tolerance story with these technologies to build applications, and how to easily implement and integrate them in a Scala Akka application for real-time delivery of meaning at high velocity, in highly distributed and concurrent environments.
Helena’s talk is now available on the Chariot Solutions site.
ReactiveCocoa is an elegant framework that radically changes the way we structure our applications and handle flows of data. However, it’s beauty is somewhat marred by Objective-C! In this talk I will cover the basics of ReactiveCocoa and the principles of Functional Reactive Programming. Through simple practical examples I will show how ReactiveCocoa and Swift form a beautiful partnership.
Colin’s talk is now available on the Chariot Solutions site. View:
Move Fast, Break Nothing
Today we are plagued by hundreds of choices when architecting a modern data center. Should our machines be virtual or physical? Should we use containers or Docker? Should we use a public cloud provider or a private cloud provider? Which configuration management tool is best to use? What about IaaS, PaaS, and SaaS? It would be manageable if these were binary choices; however, we often find ourselves in a hybrid environment.
As more operations choices are added to your data center, whether through company acquisitions, a growing development team, or general technical debt, managing complexity between legacy and new systems becomes a nightmare. Yet the end goal is still the same — safely deploy your application to your infrastructure. We need to tame our data centers by managing change across systems, enforcing policies, and by establishing a workflow for both developers and operations engineers to build in a collaborative environment.
This talk will discuss the problems faced in the modern data center, and how a set of innovative open source tooling can be used to tame the rising complexity curve. Join me on an adventure with Vagrant, Consul, and Terraform as we take your data center from chaos to control.
Seth’s talk is now available on the Chariot Solutions site.
We are experiencing a profusion of interconnected devices. Architectures are undergoing radical changes to enable better scaling and resiliency. And at the heart of all of these are several new protocols that are changing the way services communicate. A lot of interest lies with WebSocket, HTTP/2, CoAP, MQTT, XMPP, etc. What can these protocols do? What can we learn from them? And where are things going? This session will explore these questions and more.
Todd’s talk is now available on the Chariot Solutions site.
In the last decade, a class of machine learning algorithms popularly know as “deep learning” have produced state-of-the-art results on a wide variety of domains, including image recognition, speech recognition, natural language processing, genome sequencing, financial data among others.
Facebook, Google, Twitter, NVIDIA, Apple and many other tech giants are investing heavily into deep learning, which is powered by Graphics Processing Units to accelerate computation and scale up to larger and larger deep learning models.
What is deep learning? Why has it become so popular so quickly? How can one fit deep learning into existing pipelines?
Soumith’s talk is now available on the Chariot Solutions site.
Our approach to programming for the past 50+ years has mostly focused on specific features of a programming language. The result has been an emphasis on “general purpose” programming languages. The resulting language features, like object-orientation or static typing, must then be generally applicable. Where that generality fails, we expend enormous effort attempting to work around the difficulties, rather than avoiding them.
The next 10 million programs will not be built this way. We don’t have the time. We don’t have the money. And we can’t afford to fail as we have been. While the cost of almost everything is going down, the cost of failure is going up.
Relatively recently, the term ‘polyglot programming’ became popular, and there was much discussion about how different parts of a system should be written in different languages.
In this talk, I will introduce the idea of using different interoperable languages for different parts of the application life-cycle.
I will demonstrate how the Cynefin framework supports this approach to building systems. Using the Cynefin framework involves recognizing that the world is not divided into order and disorder. There are four distinct types of order.
I will also explain how it is possible to build reliable systems from unreliable components. I will answer the question: How do we structure our community, processes, and system architecture so that the reliability of the system as a whole is greater than the reliability of any particular piece?
Throughout the talk, I’ll use examples from Rubinius 3.0 to illustrate the ideas I will be presenting.
Brian’s talk is now available on the Chariot Solutions site.
Rich Hickey has previously discussed value, identity and state – but outside the context of the specifics of how we write code on the JVM. But how do these concepts correlate to the programming constructs we use to write code in Java and Scala, and how do we minimize or mitigate the impact of concurrency with them.
This talk will be an accessible exploration of the JVM Heap, thread stacks and concurrency primitives on the JVM and how to compose
multi-threaded code in Java and Scala.
Jamie’s talk is now available on the Chariot Solutions site.
Based on the ideas in Ron’s new book The Nature of Software Development, Ron and Chet will talk about the current state of “Agile Software Development”, discussing the extent to which Agile’s good ideas have been watered down, and with special attention to the current interest in “scaling” Agile.
Go is a natural fit for building web applications and services. Over the last few years the Go community has been busy creating better tools for web development in Go. Because of this surge in web frameworks, many questions have come to light:
In this talk I will attempt to answer these questions by reflection on one of my own projects, Martini, and how my open source contributions changed from building frameworks to building smaller, more idiomatic libraries.
Jeremy’s talk is now available on the Chariot Solutions site.
Last year, Miles Sabin wrote that “there is … a significant constituency at the core of the Scala community whose needs are not being fully met [by Typesafe’s focus on stability and Java 8 compatibility].” That statement summarizes the mission behind Typelevel.org, a project that currently consists of a fork of the Scala compiler, as well as various well-known Scala open source libraries.
Is this a positive and natural outgrowth of a growing and vibrant language or will this development cause irreparable rifts in the Scala community? Is this a bad thing or a good thing?
These are the issues we’ll explore during this panel. Jamie Allen, Typesafe Senior Director of Global Services, will be representing the Typesafe position. Erik Osheim, co-creator of the Typelevel project Spire, will be representing the Typelevel position. Brendan McAdams and Michael Pilquist both have Considerable experience with Typesafe and Typelevel technologies and will round out the discussion. Brian Clapper will be moderating the discussion.
We’ll discuss the issues, explore the possibilities, and field your questions. Join us.
If you’re interested in visualizing data on the Internet, the best way
documents, D3 works by marrying your data to your web page, a glorious
union that enables you to sculpt that web page into a graphical
display which mirrors exactly the structure of your data.
Uh, so what does that mean, exactly? My goal is to answer that
question in this talk. I’ll go over some of D3’s core concepts and
show, by way of an example graphic, how D3 can take raw information,
add structure to it, and create, as if by magic, an endless number of
endlessly customizable chart forms. The talk will be largely
conceptual; you won’t walk away from it with any usable snippets of
code. What you will gain, I hope, is an appreciation of D3’s power and
the underlying logic that supplies it. I’ll also direct you to some
good resources for getting started with D3 and give you some tips on
avoiding the traps that beginners tend to fall into.
Ritchie’s talk is now available on the Chariot Solutions site.
But… the bitter pill is your browser. Not all features of ECMAScript 6 will be available now, or even in the next few years, and who knows when everyone will upgrade. But if you want to take advantage of many of these features, what are you to do?
Ken’s talk is now available on the Chariot Solutions site.
You may have seen Rust on Hacker News, Reddit or Twitter, but what is all the hype about? With Rust just recently having become stable, now’s a great time to learn more about this emerging language that is taking on old stalwarts like C++ without giving up on the expressiveness of higher level languages.
In this talk, Yehuda will talk about Rust’s ownership system, which provides automatic memory management without paying the runtime cost of a garbage collector or reference counting. Instead, Rust guarantees, at compile time, that your program will never segfault. Learn how that can work, and how the same approach makes your Rust code remarkably resilient against memory leaks.
Whether you’re a grizzled systems programmer or a dynamic language programmer looking to dip your toe in, this talk will have something for you.
Yehuda’s talk is available on the Chariot Solution site.
Complex software always has an architecture, even if it isn’t intentional. But being agile isn’t enough to enough guarantee a sustainable architecture. It isn’t prudent to just keep your code clean and hope that good architecture will just emerge. Especially when there is a lot of technical risk, interdependencies, and conflicting priorities. Good architecture requires ongoing attention and stewardship. This talk presents several techniques and architectural activities that are useful on agile projects and explains how an agile architect’s role can and should differ from that of a traditional
Rebecca’s talk is now available on the Chariot Solutions site.