Tomorrow's Developer Tools

We know the cobbler's kids have no shoes, but why do developers' kids still stick to the edit/compile/debug cycle of the olden days, hunt down buffer overflows, use mutable shared state and grumble about outdated build tools? It's time to live code, use sane approaches to concurrency, and use modern build and deployment tools. In this track, we'll look at the next generation of tools and see how they help developers keep up with the demands of 21st century software development by using tools from the 21st century.

Day of week:

Monday

Location:

Seacliff A/B

Host:

Werner Schuster

Presentations

Scale effects and other stories

2:50pm - 3:40pm

By: Crista Lopes
Undercover Developer

This talk describes a few gems we found when mining the source code of 30,000 open source Java projects. You will hear about how scale affects the internal structure of projects and whether the popularity of libraries is correlated with internal software metrics such as bug density.

Coding and Languages Open Space

5:20pm - 6:10pm

By:

My other Internet is a Mirage

10:30am - 11:20am

By: Anil Madhavapeddy
Co-Author "Real World OCaml", University of Cambridge

We are now used to being roused out of bed by news of the latest serious Internet security alert or major data leak. The software services we now use are tremendously complex, and mash together a complex spectrum of policy and mechanisms. I'll talk about a different approach to building Internet services that cleanly separately both of these, and results in an extremely efficient deployment model.

Hypervisors such as Xen or VMWare provide a flexible platform to host applications as a set of appliances, e.g., web servers or databases. Each appliance usually contains an OS kernel and userspace processes, within which applications access resources via APIs such as POSIX. The flexible architecture of the cloud comes at a cost: the addition of another layer in the already complex software stack. This reduces performance and increases the size of the trusted computing base.

Our new Mirage operating system proposes a radically different way of building these appliances. Mirage supports the progressive specialisation of functional language (OCaml) application source code, and gradually replaces traditional OS components with type-safe libraries. This ultimately results in “unikernels”: sealed, fixed-purpose images that run directly on the hypervisor without an intervening guest OS such as Linux.

Developers no longer need to become sysadmins, expert in the configuration of all manner of system components, to use cloud resources. At the same time, they can develop their code using their usual compiler tools, and simply recompile into specialized kernels when ready. As they explicitly link in components that would normally be provided by the host OS, the resulting unikernels are also highly compact: facilities that are not used are simply not included in the resulting unikernel. For example, the self-hosting Mirage web server image is less than a megabyte in size!

Presentations

Xiki: GUI and Text Interfaces are Converging

1:35pm - 2:25pm

By: Craig Muth
Founder of Memorize.com

A live demo of the new version of Xiki. Xiki is part of an emerging trend: the convergence of text and GUI. Xiki is like a shell console but better. It lets you execute shell commands and code snippets to controls your web browser, databases, APIs and other tools using text alone, right from a text editor. It uses an extremely simple wiki-inspired text syntax that unifies menu interfaces, files, and code.

In Xiki, you type out new menu interfaces as text, and immediately begin using what you typed (the text itself) as GUI menus. You then create inline code snippets, or any combination of dirs, classes, scripts (in various languages), templates, and data files to provide dynamic behavior.

Xiki can be used as an IDE, a rapid prototyping tool, an interface design tool, or an embedded library (a ruby gem) in other apps.

See demos of the simplified text syntax being used to quickly create elemental but useful menus, then scaling to create sophisticated interfaces for tools including git, mysql, mongodb, rails, node.js, rspec, jquery, threejs, and many others.

You can interact with Xiki menus you obtain or create via a text editor, a mobile-ish web interface, via shell commands, or as a web service.

Core.async - Communicating Sequential Processes using Channels, in Clojure

11:45am - 12:35pm

By: Rich Hickey
Creator of Clojure, Datomic, CTO at Cognitect

There comes a time in all good programs when components or subsystems must stop communicating directly with one another. This is often achieved via the introduction of queues between the producers of data and the consumers/processors of that data. This architectural indirection ensures that important decisions can be made with some degree of independence, and leads to systems that are easier to understand, manage, monitor and change, and make better use of computational resources, etc. The objectives of core.async are:

To provide facilities for independent threads of activity, communicating via queue-like channels.
To support both real threads and shared use of thread pools (in any combination), as well as ClojureScript on JS engines.
To build upon the work done on CSP and its derivatives, e.g. Java CSP and the Go programming language.

This talk will cover the motivation, design and use of the new Clojure core.async library, the reasons for choosing the CSP approach and how it helps to structure applications.

Exploring the Future of Web Tooling with Brackets

4:05pm - 4:55pm

By: Narciso Jaramillo
Principal Scientist, Adobe

Brackets is a free, open-source code editor for front-end web development that's built in HTML, CSS and JS. Because it's built using web technologies, the people who use it are also helping to build and extend it. Moreover, the flexible nature of HTML, CSS and JS as a platform have made Brackets a great sandbox for experimenting with innovative tooling ideas for web design and development.

In this talk, we'll demonstrate some of the interesting tools and prototypes that have been built into and on top of Brackets. We'll also get under the hood, discussing the Brackets architecture and extensibility model, and describing some of the challenges and lessons we've learned building a desktop-quality tool using web technologies.