•  

Sessions at Lone Star Software Symposium on Friday 18th May

Your current filters are…

  • AMQP: From Concept To Code

    by Mark Richards

    Advanced Message Queuing Protocol (AMQP) is a new way of looking at messaging that is quickly gaining in popularity and use, particularly in the financial services industry. Unlike JMS, which defines a standard API across platforms, AMQP defines a standard wire-level protocol across languages and platforms, finally making true cross-platform messaging a reality. In this session I will start by describing exactly what AMQP is and what problems it specifically solves (that JMS can't!). I will then describe the basic architecture and how AMQP routes messages, and then, through live interactive coding, demonstrate how to build a simple producer and consumer using RabbitMQ to send and receive AMQP messages. We will also take a brief look at other aspects of AMQP such as performance and how to guarantee that the message reaches a consumer.

    Agenda: - What is AMQP and what problems does it solve? - How AMQP works: exchanges, bindings, queues, and routing - AMQP exchange types - AMQP message structure - AMQP Performance characteristics - Sending and receiving messages using RabbitMQ - How to guarantee message delivery in AMQP

    Prerequisite: basic knowledge of general messaging

    At 1:15pm to 2:45pm, Friday 18th May

  • 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 18th May

  • 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 1:15pm to 2:45pm, Friday 18th May

  • 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 18th May

  • 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:15pm to 2:45pm, Friday 18th May

  • Code Craft

    by Nate Schutta

    Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn't around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we'll read actual code discussing ways it could be improved. As we work through real examples, we'll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

    Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn't around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we'll read actual code discussing ways it could be improved. As we work through real examples, we'll explore the importance of patterns, principles like SOLID and SLAP and essential practices like unit testing and continuous integration.

    At 3:15pm to 4:45pm, Friday 18th May

  • 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 18th May

  • Integration Architecture: Concepts and Patterns

    by Mark Richards

    Very few applications stand alone anymore. Rather, they are combined together to form holistic systems that perform complex business functions. One of the big challenges when integrating applications is choosing the right integration styles and usage patterns. In this session we will explore various techniques and patterns for application integration, and look at what purpose and role open source integration hubs such as Camel and Mule play in the overall integration architecture space (and how to properly use them!). Through actual integration scenarios and live coding examples using Apache Camel you will learn which integration styles and patterns to use for your system and how open source integration hubs play an part in your overall integration strategy

    Agenda:

    • Introduction: the need for integration
    • Integration Styles: pros, cons, and when to use
    • Integration Hubs: why do we need them?
    • Integration Hub Building Blocks
    • Common Integration Patterns
    • Understanding the different roles of an integration hub

    At 3:15pm to 4:45pm, Friday 18th May

  • 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 18th May

  • 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 3:15pm to 4:45pm, Friday 18th May

  • 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 18th May

  • Functional Thinking

    by Neal Ford

    Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard.

    This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional langauges as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you'll leave with a much better understanding of both the syntax and semantics of functional languages.

    At 5:00pm to 6:30pm, Friday 18th May

  • Leading Technical Change

    by Nate Schutta

    Technology changes, it's a fact of life. And while many developers are attracted to the challenge of change, many organizations do a particularly poor job of adapting. We've all worked on projects with, ahem, less than new technologies even though newer approaches would better serve the business. But how do we convince those holding the purse strings to pony up the cash when things are "working" today? At a personal, how do we keep up with the change in our industry?

    This talk will explore ways to stay sharp as a software professional. We'll talk about how a technology radar can help you stay marketable (and enjoying your career) and how we can use the same technique to help our companies keep abreast of important changes in the technology landscape. Of course it isn't enough to just be aware, we have to drive change - but how? This talk will consider ways we can influence others and lead change in our organizations.

    At 5:00pm to 6:30pm, Friday 18th May

  • MongoDB: Scaling Web Applications

    by Ken Sipe

    Google “MongoDB is Web Scale” and prepare to laugh your tail off. With such satire, it easy to pass off MongoDB as a passing joke… but that would be a mistake. The humor is in the fact there seems to be no end to those who parrot the MongoDB benefits without a clue. This session is about getting a clue.

    Get past the hype and hyperbole associated with NoSQL. This session will introduce MongoDB through live working sessions demonstrating the pros and cons of MongoDB development. The session will then focus on a recent short project focused on large scale. We’ll discuss database design to support high scale read access. Throughout this case study we will discuss the consequences of the MongoDB choice. The session will finish with a review of the production topology to support growth in scale.

    At 5:00pm to 6:30pm, Friday 18th May

  • The Art of Problem Solving

    by Mark Richards

    I commonly think of those of us in the IT industry as problem solvers. Whether developer, designer, or architect, we are all presented with problems and work to find a way to solve them, usually through technology. In my opinion this is what makes this industry so much fun. Let's face it - we all love challenges. Sometimes, however, the problems we have to solve are hard - really hard. So how do you go about solving really hard problems? That's what this session is about - Heuristics, the art of problem solving. In this session you will learn how to approach problems and also learn some the common techniques for solving them effectively. So put on your thinking cap and get ready to solve some easy, fun, and hard problems.

    Agenda:

    • the checklist
    • visual representations
    • you know what happens when you assume...
    • you gotta start somewhere
    • hey! keep it clean!
    • working backwards
    • we should take the trail to the left...I think...
    • the world is flat

    Prerequisite: An open mind and a willingness to learn how to better approach and solve problems

    At 5:00pm to 6:30pm, Friday 18th May