•  

Central Iowa Software Symposium schedule

Friday 3rd August 2012

  • Continuous Delivery Pt 1: Deployment Pipelines

    by Neal Ford

    Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. This workshop focuses on the Deployment Pipeline concept from Continuous Delivery.

    In this workshop I move from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. I spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.

    At 1:15pm to 2:45pm, Friday 3rd August

  • NoSQL Smackdown 2012

    by Tim Berglund

    Alternative databases continue to establish their role in the technology stack of the future—and for many, the technology stack of the present. Making mature engineering decisions about when to adopt new products is not easy, and requires that we learn about them both from an abstract perspective and from a very concrete one as well. If you are going to recommend a NoSQL database for a new project, you're going to have to look at code.

    In this talk, we'll examine three important contenders in the NoSQL space: Cassandra, MongoDB, and Neo4J. We'll review their data models, scaling paradigms, and query idioms. Most importantly, we'll work through the exercise of modeling a real-world problem with each database, and look at the code and queries we'd use to implement real product features. Come to this session for a thorough and thoroughly practical smackdown between three important NoSQL products.

    At 1:15pm to 2:45pm, Friday 3rd August

  • Programming with HTML 5

    by Venkat Subramaniam

    Developing a rich user interface for web applications is both exciting and challenging. HTML 5 has closed the gaps and once again brought new vibe into programming the web tier. Come to this session to learn how you can make use of HTML 5 to create stellar applications.

    At 1:15pm to 2:45pm, Friday 3rd August

  • Resource-Oriented Architectures : REST I

    by bsletten

    The first in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

    The REpresentational State Transfer (REST) architectural style has emerged as a winning strategy for building scalable, flexible, resilient systems that lead with an information focus. Far from being the simple "Web Services through URLs" idea many people have about them, REST-based systems require a new perspective, a fair amount of consideration and the discipline to look beyond simple point-to-point interactions.

    The benefits are exciting and provide a gateway to a whole new world of information technology. This first talk will be an introductory session covering the basics of the REST architectural style.

    At 1:15pm to 2:45pm, Friday 3rd August

  • Turtles, Architecture, & Agility

    by Kirk Knoernschild

    A little old lady once challenged a well-known scientist’s explanation on the structure of the universe, countering that the world is really a flat plate supported on the back of a giant tortoise. The scientist rebutted the little old lady’s challenge with one of his own by asking what the tortoise was standing on. The little old lady’s sly reply was that it’s, “turtles all the way down.” So too is software architecture “turtles all the way down”.

    In this session, we cover a broad range of topics that include challenging traditional practices of software architecture, examining what it takes to bring down the ivory tower, probing the paradoxical aspects of architecture’s goal, and investigating the inextricable link between temporal decisions and structural flexibility. From the highest level applications and services to the code that exists in the bowels of the system, and everything in between, we explore how an effective software architecture must be turtles all the way down. In the end, we will all have gained deep insight to the value of agile architecture.

    At 1:15pm to 2:45pm, Friday 3rd August

  • Connected Data with Neo4j

    by Tim Berglund

    Neo4j is an open-source, enterprise-class database with a conventional feature set and a very unconventional data model. Like the databases we're already used to, it offers support for Java, ACID transactions, and a feature-rich query language. But before you get too comfortable, you have to wrap your mind around its most important feature: Neo4j is a graph database, built precisely to store graphs efficiently and traverse them more performantly than relational, document, or key/value databases ever could.

    Neo4j is an obvious fit to anyone who thinks they have a graph problem to solve, but this is not many people. It turns out that the most interesting property of Neo4j is its architectural agenda. It wants you to think of the entire world as a graph—as a set of connected information resources. Steeped in the thinking of resource oriented architecture, this NoSQL database wants to change the way you look at your world, and unlock new value in your data as a result.

    At 3:15pm to 4:45pm, Friday 3rd August

  • Continuous Delivery Pt 2: Infrastructure

    by Neal Ford

    Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. This workshop focuses on the agile infrastructure required to implement a deployment pipeline and continuous delivery.

    In this workshop, I introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.

    At 3:15pm to 4:45pm, Friday 3rd August

  • OSGi Demystified

    by Kirk Knoernschild

    OSGi was once heralded as a contender for most important technology of the decade. Today, most developers have heard of OSGi, but few are using it to develop their enterprise software applications.Is OSGi failing? Who is using it? And what exactly are its benefits?

    In this session, we'll explain the benefits of OSGi, and show that it's not just for the middleware vendor. We'll learn how you can use OSGi without making significant changes to how you write your software applications. We'll explore the OSGi ecosystem, including platforms that support OSGi. Through code examination, we'll see how the Spring framework allows us to leverage OSGi in a non-invasive way. We'll discover how OSGi encourages Polyglot programming on the Java platform. And we'll take a brief glimpse into the future of modularity on the Java platform. You'll walk away with a much better understanding of OSGi, its strengths and benefits, how to use it effectively, as well as the myths surrounding its use.

    At 3:15pm to 4:45pm, Friday 3rd August

  • Rediscovering JavaScript

    by Venkat Subramaniam

    JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It's quite popular, yet there's so much more we can do with it.

    In this presentation we'll deep dive into the capabilities and strengths of this prominent language of the web.

    At 3:15pm to 4:45pm, Friday 3rd August

  • Resource-Oriented Architectures : REST II

    by bsletten

    The second in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

    People already familiar with REST (or who have attended the first session) will be walked through the deeper topics of building Level 3 Hypermedia-based RESTful systems, security, content negotiation, etc.

    At 3:15pm to 4:45pm, Friday 3rd August

  • Automated testing tools and techniques for JavaScript

    by Venkat Subramaniam

    Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability is a design issue and with some discipline and careful design we can realize good automated tests.

    In this presentation we'll learn how to automate the testing of JavaScript using both TDD and BDD tools.

    At 5:00pm to 6:30pm, Friday 3rd August

  • Build Your Own Technology Radar

    by Neal Ford

    A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company.

    ThoughtWorks' Technical Advisory Board creates a "technolgy radar" 3 or 4 times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This session describes the process we use and how to adapt it to both your company and, more importantly, yourself. For career risk mitigation, you must know what the next big thing is, or at least be able to narrow it to a reasonable list. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organization) develop a cogent strategy to make good choices.

    At 5:00pm to 6:30pm, Friday 3rd August

  • Hadoop

    by Tim Berglund

    When you want to measure fractions of a millimeter, you get a micrometer. When you want to measure centimeters, you get a ruler. When you want to measure kilometers, you might use a laser beam. The abstract task is the same in all cases, but the tools differ significantly based on the size of the measurement.

    Likewise, there are some computations that can be done quickly on data structures that fit into memory. Some can't fit into memory, but will fit on the direct-attached disk of a single computer. But when you've got many terabytes or even petabytes of data, you need tooling adapted to the scale of the task. Enter Hadoop.

    Hadoop is a widely-used open source framework for storing massive data sets in distributed clusters of computers and efficiently distributing computational tasks around the cluster. Come learn about the Hadoop File System (HDFS), the MapReduce pattern and its implementation, and the broad ecosystem of tools, products, and companies that have grown up around this ground-breaking project.

    At 5:00pm to 6:30pm, Friday 3rd August

  • Modular Java Architecture - TODAY!

    by Kirk Knoernschild

    Modularity is coming to the Java platform! Java 8 will introduce the Jigsaw module system. OSGi is here today. Don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!

    In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.

    At 5:00pm to 6:30pm, Friday 3rd August

  • Resource-Oriented Architectures : REST III

    by bsletten

    The third in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.

    The move to a good REST API yields an explosive combination of options due to content-negotiation and arbitrary workflows. At the same time, the uniform interface you project (representations, how you respond to verbs, response codes, etc.) becomes your contract with your clients. The API itself becomes a completely transportable, reusable bit of organizational knowledge when done well. Testing it sufficiently will give you a safety net but may drive you crazy unless you do it right. We will walk through the use of Behavior-Driven Development (BDD) to test these kinds of APIs.

    We will highlight the problems of sufficiently testing REST APIs while providing a rich and relatively straight-forward solution to the problem. We will use a Behavior-Driven Development (BDD) tool like Cucumber to establish reusable steps and comprehensive, but lightweight testing strategies for testing REST APIs.

    This talk will not be an introduction to REST. If you have come to the REST I or REST II talk, or have a good understanding, it should be very accessible.

    Prerequisite: Resource-Oriented Architectures : REST I (or a good understanding of REST)

    At 5:00pm to 6:30pm, Friday 3rd August

  • Then Our Buildings Shape Us

    by Tim Berglund

    Winston Churchill famously said, "First we shape our buildings, and afterwards, our buildings shape us." He was talking about the reconstruction of the House of Parliament, which was damaged in a bombing raid in World War II. There was a debate about how to shape the chamber to best accommodate the deliberative activity of the body that met in it. Churchill was talking about buildings, but it turns out his insight is a very general one indeed.

    Developers are constantly debating their choices of language, platform, editor, methodology, and even where to put the curly braces. The robust internal dialog in community is a healthy thing, but our debates are often focused on the wrong topics. Have you ever compared languages by performance benchmarks? Platforms by alleged claims of developer productivity? Methodologies by feature velocity? There is a very good chance you're doing it wrong.

    Rather than focus on the material content of our debates—language performance, editor productivity, methodological velocity—we should take Churchill's advice and think about the form of our choices. How will our choice of language influence the way we solve future problems? What assumptions does our methodology make about the nature of work? How will our choice of database affect the kinds of problems we think of as solvable?

    Drawing on lessons from building architecture, literature, music, the visual arts, and even software itself, we'll learn the priority of interpreting the form of things before attempting to understand their content. You may never look at software architecture the same way again.

    At 7:15pm to 8:00pm, Friday 3rd August

Saturday 4th August 2012

  • Agile Engineering Practices

    by Neal Ford

    Most of the time when people talk about agile software development, they talk about project and planning practices and never mention actual development practices. This talk delves into best development practices for agile projects, covering all of its aspects.

    Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development where an afterthought when writing software. This talk bills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.

    Prerequisite: Having worked in an organization that values bureaucracy more than individuals

    At 9:00am to 10:30am, Saturday 4th August

  • Effective Spring

    by Craig Walls

    After 9 years and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?

    In this session, we'll explore several ways that Spring has changed over the years and look at the best approaches when working with the latest versions of Spring.

    At 9:00am to 10:30am, Saturday 4th August

  • Groovy Power Tools

    by Ken Sipe

    Groovy has been around for some time and is generally recognized as a highly productive object-oriented language with a tight association with Java. Groovy seems to be going through a second wave of popularity with a more diverse repertoire of benefits, including building, deploying and testing, in addition to rapid web development. The fastest growth of productivity tools are all powered by Groovy. Discover the Groovy Truth!

    This session will start with a short introduction to Groovy and will walk through a number of groovy tools that can increase the speed of delivery of any Java software development shop. We will review the following Groovy Power Tools: - Spock - the best unit testing and mocking tool available to a Java developer leveraging the value of a testing DSL - Gradle - the fasting growing build tool for compiling and building Java-eco system projects. - Geb - A groovy DSL on top of Selenium for driving web testing - Glu - The groovy way to deploy and manage Java deployments in production - Grails - The groovy way to develop a web application against a relational database

    At 9:00am to 10:30am, Saturday 4th August

  • Semantic Web Workshop

    by bsletten

    The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

    Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

    Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

    In this workshop, we will:

    Explain the Web and Web architecture at a deeper level Apply Web and Semantic Web technologies in the Enterprise and make them work together Integrate structured and unstructured information Create good, long-lived logical names (URIs) for information and services Use the Resource Description Framework (RDF) to integrate documents, services and databases Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)

    Bring your laptops. This is a hands-on workshop.

    At 9:00am to 10:30am, Saturday 4th August

  • Thinking in Functional Style

    by Venkat Subramaniam

    Functional Programming has been around for a while, but it is gaining popularity, especially due to direct support in languages on the JVM. Writing code in functional style is not about syntax, it is a paradigm shift. In this presentation, using examples from Java, Groovy, and Scala, you will learn how to write code in functional style. We will start out discussing the elements of functional programming and then look at examples of some common operations and how you can implement those in functional style.

    At 9:00am to 10:30am, Saturday 4th August

  • Developing Next-Generation Applications

    by Craig Walls

    For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.

    But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.

    With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.

    In this session, we'll discuss what the next generation of applications looks like, exploring such things as the mobile web and cloud computing. We'll also dig into some of the technologies and practices such as REST, OAuth, and JavaScript microframeworks that enable us to move forward.

    At 11:00am to 12:30pm, Saturday 4th August

  • Scala Koans - A new and fun way to learn a Scala programming language

    by Venkat Subramaniam

    Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.

    If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?

    Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.

    At 11:00am to 12:30pm, Saturday 4th August

  • Scaling Agility

    by Kirk Knoernschild

    We know agile methods are proven on small teams, but really...almost any process works with a team of one. As the team scales, however, the challenges mount. In this session, we focus on proven practices that help large software development teams in excess of 100 developers maintain agility. We also explore how to scale agile across the enterprise.

    Come learn about ways to increase transparency on large projects, structure the development team, garner the important feedback you need from customers, and avoid the lack of rhythm so common on large teams. We’ll explore how large teams can conduct effective code reviews, maintain a consistent architectural vision, take advantage of automation, and build a development process that is sustainable on large teams. In lieu of focusing on specific agile methods in this session, we turn our attention to practices that the development team can leverage today to get started on the road to increased agility.

    At 11:00am to 12:30pm, Saturday 4th August

  • Semantic Web Workshop

    by bsletten

    The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

    Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

    Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.

    In this workshop, we will:

    Explain the Web and Web architecture at a deeper level Apply Web and Semantic Web technologies in the Enterprise and make them work together Integrate structured and unstructured information Create good, long-lived logical names (URIs) for information and services Use the Resource Description Framework (RDF) to integrate documents, services and databases Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)

    Bring your laptops. This is a hands-on workshop.

    At 11:00am to 12:30pm, Saturday 4th August

  • Spock - Unit Test and Prosper

    by Ken Sipe

    Spock is a groovy based testing framework that leverages all the "best practices" of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans... and you get Spock!

    This is a significant advancement in the world of testing.

    This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool.

    Prerequisite: junit

    At 11:00am to 12:30pm, Saturday 4th August

  • Programming Concurrency with Akka

    by Venkat Subramaniam

    I call the JDK concurrency API as the synchronize and suffer model. Fortunately, you don't have to endure that today. You have some nice options, brought to prominence on the JVM by Scala and Clojure.

    In this workshop, learn how to program with Actors and STM using Akka, a powerful and popular library created using Scala but usable from any language on the JVM. You have a choice to pick the language you like in this workshop, and learn how to use these powerful concurrency models.

    At 1:30pm to 3:00pm, Saturday 4th August

  • Spring Data

    by Craig Walls

    This session starts with a high-level look at all that the Spring Data project has to offer. Then we'll dive deeper into a few select Spring Data modules, including Spring Data Neo4j, Spring Data MongoDB, Spring Data Redis, Spring Data JPA, and Spring Data JDBC Extensions

    In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.

    With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.

    Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new "NoSQL" databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.

    At 1:30pm to 3:00pm, Saturday 4th August

  • The Who and What of Agile - Personas and Story Maps

    by Nate Schutta

    Successful projects require any number of practices but if you don't know who you're building it for or what you're supposed to build, failure is a distinct possibility. How do we capture the who and what? Personas and story maps are two effective techniques that you can leverage. After discussing the basics, we'll break into small groups and you'll have a chance to actually try building a set of personas as well as a story map.

    Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months and months of effort.

    Of course just knowing who we're building for is only part of the picture, we have to know what our users are trying to do. Wether you favor use cases, user stories or more traditional requirements documents, at the end of the day our customers are using our application to further some other goal.

    At 1:30pm to 3:00pm, Saturday 4th August

  • Visualizing Data on the Web

    by bsletten

    We are far from the early days of ugly HTML. We have sophisticated visualization tools available to us now to help our users consume complex data in attractive and informative ways.

    Come hear how you can adopt these visualization systems (calling them libraries is inappropriate) today.

    This talk will introduce:

    • D3.js
    • RGraph
    • SVG in the Browser
    • Highcharts
    • Raphael
    • Reusable widgets from the Simile Project

    At 1:30pm to 3:00pm, Saturday 4th August