Central Iowa Software Symposium
Jul 30 - Aug 1, 2010 - Des Moines, IA
View the event details here ».
Rohit Bhardwaj - Principal Software Engineer, Kronos Inc Expert in agile development
Android mobile application development: Cool apps that surprise and delight mobile users—built by developers like you
Android is a software stack for mobile devices that includes an operating system, middleware and key applications. Cool apps that surprise and delight mobile users—built by developers like you—are a huge part of the Android vision. In this presentation we will explore many examples of android.
In this session we will take a deep dive at few cloud computing examples from real world and participants will be able to know how to use cloud computing for Google App Engine, Amazon EC2 and few others.
Data integrity, security, recovery, privacy and regulatory compliance are most important attributes for enterprise implementation. Enterprise customers ask for transparency in how the vendors will provide security programs. Many question need to be asked for any cloud implementation to policy makers, architects, coders and testers.
In this presentation we will explore data security and storage, privacy and data compliance issues. We will explore the security management in cloud. Presentation is useful for anyone starting from Executives to developers who are going to implement the enterprise Applications in both private and public cloud.
Enterprise software solutions are an essential part of many large enterprises. Given the critical role enterprise software solutions play, it is imperative that they are tested effectively and efficiently all the time. It is as important, if not the most important, as any other phase of the Software Development Lifecycle (SDLC). But testing an enterprise application is easier said than done. This presentation targets seasoned software developers, testers and project managers who are looking for guidance in implementing an effective application testing strategy. We will discuss the rationale behind application enterprise testing and explore building blocks of effective testing and explain their importance. Then we will explore how to do effective root-cause analysis. We will discuss the typical output of a performance test and how to perform effective analysis. We will learn the effects of particular software environments on testing. The approach is generic; so many details regarding your applications will depend on the characteristics of the technologies you use. Later on we will explore at two tools PushToTest and CloudTest to automatically test web applications. Attendees will learn different test strategies for testing.
Jeff Brown - Core Member of the Grails Development Team
Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)
The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.
GORM is a super powerful ORM tool that makes ORM simple by leveraging the flexibility and expressiveness of a dynamic language like Groovy. With GORM developers get access to all of the power and flexibility of an ORM tool like Hibernate without any of the complexity.
Prerequisite: Advanced Grails
Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.
Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming.
Prerequisite: Advanced Grails
Neal Ford - Application Architect at ThoughtWorks, Inc.
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.
Prerequisite: Having worked in an organization that values bureaucracy more than individuals
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
Prerequisite: understanding of architectural and design concepts
This talk describes an agile approach to architecture, and merges the current state-of-the-art thinking in both service oriented architectures(SOA) and web-based architectures like HTTP, REST, and hypermedia.
This talk covers testing the entire stack: unit, integration, functional, behavior-driven, databases, user acceptance, mocking & stubbing, and other topics and strategies.
Prerequisite: Confusion about what to test when and where
David Hussman - Agility Coach/Instructor/Practioner
Many people simplistically apply agile recipes, assuming a one size fits all approach. This may lead to naive use beliefs like collocation breeds instant success. While sitting together always helps, it does not mean that people spontaneously collaborate to create sustainable value.
Instead of approaching agile methods like a recipe, this session will teach you to design agility that is a useful tool for your project community. We will cover practice selection ideas, tools for creating healthy development eco-systems and product discover tools. If you would like to improve the stickiness of your agility, stop in learn a pile of techniques to use before holding your first planning session.
If you want to introduce meaningful agility in your company, real change takes more than a few certification courses or one successful pilot project. Process that produces tangible results sticks while dogmatic preaching is short lived. If you are planning to grow agility that helps you produce better products and better code in meaningful timeframes, stop in and learn how to succeed and how to avoid common failures.
Design tends to mean one thing to developers and another thing to designers. The later group are product designers and are not aware of the structure of the code.
The hipsters in the agile community are trying to blend product design into the process of coding and delivering software. This session discusses what to do after your agility is flowing, or post agilism: imagine you using agile methods successfully, what's next?
What stops you from delivering to your customers and what truly prevents incremental learning in your project community? How much of it lies in coding issues? Do you even need to write code to learn where to go or how to get there?
For many companies, being agile means producing working code from an iteration. While working code is a measure of progress, and provides a tool to validate success, it is not always your best investment. Your best investment lies in combining 1) what helps you learn about your product and your market and 2) what you need to do to deliver it, and what is constraining either of these.
Matthew McCullough - Head of Training, GitHub
Does your application transmit customer information? Are there fields of sensitive customer data stored in your DB? Can your application be used on insecure networks? If so, you need a working knowledge of encryption and how to leverage Open Source APIs and libraries to make securing your data as easy as possible. Cryptography is quickly becoming a developer's new frontier of responsibility in many data-centric applications.
Now that you have the basics of encryption under your belt, we'll advance to talking about where it is sensible and performant to add this level of security to your application. Symmetric key and public key encryption have various levels of processing overhead, so you can't blindly just use the "best" encryption out there. What about password hashes? Did you know they are vulnerable with our "salt"?
Prerequisite: Encryption Bootcamp on the JVM
With the basics of Hadoop under your belt, we'll dig into the depths of this amazing framework by writing our own reducer in Java and deploying it to the cluster. Next, we'll dig deeper into DSLs like Pig and its log-file processing cousin, Chukwa. Since grid topology is intentionally very opaque in Hadoop, we'll look at the benefits and how to achieve a properly tuned cluster with replication. Specific to HDFS, we'll tune the configurable parameters for storage redundancy and bucket sizes.
Prerequisite: Hadoop: Divide and Conquer Gigantic Datasets (Intro)
Moore's law has finally hit the wall and CPU speeds have actually decreased in the last few years. The industry is reacting with hardware with an ever-growing number of cores and software that can leverage "grids" of distributed, often commodity, computing resources. But how is a traditional Java developer supposed to easily take advantage of this revolution? The answer is the Apache Hadoop family of projects. Hadoop is a suite of Open Source APIs at the forefront of this grid computing revolution and is considered the absolute gold standard for the divide-and-conquer model of distributed problem crunching. The well-travelled Apache Hadoop framework is curently being leveraged in production by prominent names such as Yahoo, IBM, Amazon, Adobe, AOL, Facebook and Hulu just to name a few.
Explore what's new on the cutting edge release of Maven, version 3.0. We'll explore the performance improvements, features that make debugging Maven issues easier, and changes to POMs that may require modifications to your build, but will result in more determinate build outputs.
Ted Neward - Enterprise, Virtual Machine and Language Wonk
Fred Brooks said, "How do we get great designers? Great designers design, of course." So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.
The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than "Hello world". The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.
Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right?
Prerequisite: Busy Java Developer's Guide to Collections
Games? What do games have to do with good business-oriented applications? Turns out, a lot of interesting little tidbits of user-interface, distribution, and emergence, found normally in the games we play, have direct implications on the way enterprise applications can (or should) be built.
Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)... it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.
For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes.
Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used.
Nathaniel Schutta - Author, speaker, software engineer focused on user interface design.
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
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.
The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.
While your project might have nearly 100% code coverage on the server tier, many projects ignore testing the web layer. With more and more code being pushed to the browser, a lack of tests for the client code begs for trouble.
Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.
Ken Sipe - Architect, Web Security Expert
The agile development process is all about early and often feedback. One aspect of feedback is how is the team doing... Are we accurate in our estimates? Are we consistent in our velocity? As velocity varies, what is it telling me?
The agile focus of software development puts heavy focus on user requirements through user stories. However we can not lose sight of the non-functional requirements as well. The software could be written to the exact specification and desire of the user, however if it takes 5 minutes for a request response, or it only supports 2 users or it isn't secure, then we still haven't done our jobs as developers.
So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.
This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.
When it comes to cross cutting software concerns, we expect to have or build a common framework or utility to solve this problem. This concept is represented well in the Java world with the loj4j framework, which abstracts the concern of logging, where it logs and the management of logging. The one cross cutting software concern which seems for most applications to be piecemeal is that of security. Security concerns include certification generation, SSL, protection from SQL Injection, protection from XSS, user authorization and authentication. Each of these separate concerns tend to have there own standards and libraries and leaves it as an exercise for the development team to cobble together a solution which includes multiple needs.... until now... Enterprise Security API library from OWASP.
This session is a quick look at all aspects of being a corporate software architect. Whither you are a developer looking to move into the role of architect, needing to have an understanding of what is expected or already in the role of software architect looking for new and interesting ideas, this session is for you.
Brian Sletten - Forward Leaning Software Engineer
If you have come to the NetKernel overview talk and came away compelled but unsure how to proceed, this talk will jump right in to building real resource-oriented systems with NetKernel. We will move away from the theoretical mind-melting right into the applied mind-melting. It is difficult to make the shift away from an object-oriented model, but this talk will demonstrate several examples of how and why you may want to. It will also include a preview of what is coming in NetKernel 4. This is kind of a REST + Polyglot Programming + SOA + Architecture talk all rolled up into one.
Prerequisite: Intro to NetKernel : Software for the 21st Century, Give it a REST (if unfamiliar with REST)
HTML 5 is an adventurous and confusing prospect that will help change the Web as we know it. It is being finalized as a standard but won't be fully supported by most browsers for quite some time. Companies like Apple and Google have already committed to it as the future of Web application development, however. There are a huge number of new features, updates and gotchas coming at us (including the proverbial kitchen sink!) so it is time to get prepared. This talk will walk you through the new bits and try to put it all into perspective.
Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.
NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
Come see how this open source / commercial product can change the way you think about building software.
There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.
If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.
Venkat Subramaniam - Founder of Agile Developer, Inc.
You can't be agile if your code sucks. You know that you have to constantly refactor your code and design. But the questions is how? In this presentation, instead of looking at a laundry list of refactoring techniques, we will instead look at how to effectively approach refactoring and along the way discuss some core principles to look for.
Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.
Scala is a very powerful hybrid functional pure object oriented language on the JVM. Scala is known for its conciseness and expressiveness. In this presentation we will look at some common tasks you do everyday in developing applications and see how they manifest in Scala.
In this presentation we will take a quick walk though the issues with concurrency and how the solutions provided in Scala and Clojure help address those.
Once I got convinced about the benefits of TDD, I used it pretty extensively and consistently to drive the design and development of my code. So, it came as a surprise when I was trying to convince myself that those practices do not apply on a highly multithreaded code I was creating on a project. Thankfully, I set out to prove that TDD does not apply, but ended up proving myself wrong.
Groovy is a elegant, dynamic, agile, OO language. I like to program in Groovy because it is fun and the code is concise and highly expressive. Writing code in a language is hardly about using its syntax, however. It is about using the right idioms. Come to this section to pick up some nice Groovy idioms.
Prerequisite: Some knowledge of Groovy is helpful but not required.
Java has come a long way, and yet there is so much that's happening in this space. In this presentation we will take a look at the exciting additions and changes coming up in the next version of Java.
Prerequisite: Good programming knowledge of Java
Craig Walls - Author of Spring in Action
In this session, we'll start with the basics of Spring MVC development, focusing on how to leverage the new annotation-driven model. With that foundation set, we'll continue by exploring the new features in Spring 3.0 and 3.1 to build RESTful web applications that can serve both human-facing content as well as resources that are consumed by machine clients.
In this example-driven session we'll see how to swiftly develop Spring applications using Spring Roo. We'll start with an empty directory and quickly work our way up to a fully functioning web application. You'll see how Roo handles a lot of heavy-lifting that you'd normally have to do yourself when working with Spring. And we'll stop at a few scenic points along the way to see how Roo accomplishes some of its magic.
Contrary to what you may have heard, OSGi is neither complex, nor heavyweight. In this session, I'll show you how OSGi can actually simplify application development rather than complicate it. We'll look at the benefits of modularity, the fundamentals of OSGi, and see how to develop basic OSGi bundles. We'll also see how a few gadgets in the OSGi toolbox can ease the development of OSGi bundles.
In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.