"Seven Languages in Seven Weeks" and "Code Complete 2" were under my Christmas tree and I'll be telling you why. I'll also be talking about gaming with the HTML5 canvas tag and how I experienced (near) instant gratification with Ruby on Rails on Heroku.
Topics
I'll give a brief overview of my technology plans for 2011, including diving into Groovy, sampling a non-JVM language (Perl 6), and experimenting in the mobile space with Android. For each topic, I'll give a brief overview of the technology, discuss my goal for the year, and talk about how I plan to meet that goal.
Slides available here: crazysmoove.com/memjug/2011_resolutions/
(This is an HTML slideshow presentation that works best in Firefox, Chrome, and Safari.)
Creating and maintaining a solid automated test suite is critical to an Agile strategy, but often we're just told to "Do it." In this talk we'll look at several pragmatic strategies for creating and building your suite.
We'll examine these strategies and then look at scenarios for using them next week. This presentation will get you started whether you're starting a new project or trying to clean up an existing one.
One of the hallmarks of lean software development is the elimination of waste. Several of the key wastes in software development revolve around incomplete, incorrect, or obsolete documentation, especially documentation of requirements. One effective means of ensuring that your requirements documentation is complete, correct, and up-to-date is to make it executable. That sounds nice, but how do we get it done, especially in the world of modern, cross-browser web applications?
Executable web application specifications are within your reach through the combination of Spock, a testing and specification framework written for the JVM in Groovy, and Geb, an elegant Groovy wrapper around the powerful WebDriver browser automation framework. In this session we'll take a close look at Spock specifications for describing and verifying the behavior of our applications. We'll then examine how we can use Geb's implementation of the Page Object pattern and its "jQuery-ish" API for interacting with our web applications in WebDriver's range of supported browsers. Finally, by gluing these two technologies together via Geb's Spock integration, we'll automate the requirements specification for a simple web app.
This talk focuses on a few technical books that have been very important to my growth as a developer/programmer. (I hope there are a few surprises in the list.) It concludes with a perspective on what I regard as one of the greatest dangers facing our profession.
I'll give a brief overview of my technology plans for 2011, including diving into Groovy, sampling a non-JVM language (Perl 6), and experimenting in the mobile space with Android. For each topic, I'll give a brief overview of the technology, discuss my goal for the year, and talk about how I plan to meet that goal.
Spring was first released in 2003 as an alternative to using EJBs for developing Java-based web sites and enterprise applications. Since then, the original Spring project has grown to include libraries for working with databases, security frameworks, and the REST style of accessing web resources. We'll start off with an overview of the core part of Spring, the dependency injection framework. We'll build on that foundation to create a web site using Spring MVC, then add security features using Spring Security. Finally, we'll briefly discuss how Spring WebFlow makes it easier to create multi-page wizards as part of a web site. Parts of the presentation will involve live coding, so feel free to bring your laptop and follow along. We'll be using the latest version of Spring (3.1 M2) and the Springsource Tool Suite (STS), a customized version of Eclipse built by the maintainers of the Spring framework. Both are available for free download from the Spring web site (springsource.org).
Has your career been a random product of your manager’s whims or company’s needs? Never rely on your company to keep your skills current and marketable. Take control of your own career with a proven strategy.
These are solid, repeatable steps to get your career in the trajectory you want. The first step is deciding where you want to go. We’ll walk through creating a long-term plan, then break it down into manageable steps. Learn to lead within your own company, then stretch out to your local, regional and national community, building your reputation as you go. From coding to writing to speaking, each step will move you closer to where you want to be: in a position of having options and in control of your career.
This talk will focus on careers in the field of Bioinformatics. Bioinformatics is an emerging field that involves application of computational skills to the field of biology. Because of the vast amount of data generated in biological research, there is a need for software tools that can efficiently manage the data and analyze it. In this presentation, I'll describe the field of bioinformatics,what kind of skills are normally required to work in this field, and what kind of employers seek candidates with bioinformatics skills.
Developing an enterprise-level Java application is a daunting task. It comes with lot of classes and configurations. Generating and navigating through the classes can be a very arduous task. You have a lot of free tools to help you out with all the staff. The benefits of eclipse and some of the plug-ins including fast code eclipse plug-in
will be presented with live coding.
The talk will cover how Data Grids can reduce the workload on backend databases and scale well beyond traditional caches. Some better known Data Grids are products like IBM's WebSphere eXtreme Scale, Oracle's Coherence, JBoss Infinispan and Terracotta.
What is it that we're really paid to do as developers? Writing code? Not a chance. Organizations pay us to deliver value. I'll be looking at three books that help us deliver more:
- The Passionate Programmer - Chad Fowler
- The Pragmatic Programmer - Andy Hunt and Dave Thomas
- The Productive Programmer - Neal Ford
This talk will give a quick overview of deploying Grails web applications to Morph AppSpace.
In the Java build space, first there was ANT, which provided a reliable way to build without an IDE. Then there was Maven, which provided standardization in build life cycles and dependency management. Now... Enter the Gradle, which provides convention over configuration approach to the build process and an approach at building that isn't based XML.
This session assumes no familiarly with Gradle as it introduces this new approach at building projects. It is very helpful to be able to read and understand groovy to get the most from the session. This session will look at multi-language or polyglot projects, as well as integration to ANT and Maven. It will conclude with building custom plugins for the Gradle build process.
The new HTML5 spec includes a small API that supports in-browser geolocation functions using JavaScript.
Slides are here: crazysmoove.com/memjug/geolocation/ and will probably render best in Chrome or Firefox.
Groovy is a dynamic Java dialect that makes programming on the JVM fun again. Couple that with Grails, the agile full-stack MVC web framework built on Grails and other best-of-breed technologies, and you have the potential to deliver huge amounts of value to your customers (and make a nice profit along the way!) This presentation will take a brief tour of both of these technologies and then hop off of the trail to go exploring wherever your interests lie!
The Groovy trail:
Syntactic sugar
Dynamic (Duck) Typing
Closures
Metaprogramming
The Grails trail:
Stack overview
Scaffolding quick start
Domain classes/GORM
Controllers
Groovy Server Pages (GSP)
Tag Libraries
I have programmed in GWT for more than 3 years. For this talk I want to share with the audience my experience of using GWT as an active end user. Overall, GWT is a relatively non-intrusive, high performance Ajax technology that shall feel natural for Java developers. Besides a decent set of pre-built UI widgets, it provides out-of-box support for cross-browser compatibility, internationalization, resource bundling, conditional CSS, cross domain scripting, and high performance widgets used to display huge amount of data. In addition, GWT is compatible with other front end technologies such as JSP and jQuery. So using GWT does not force you to rewrite your existing code. Furthermore, GWT provides excellent dependency injection mechanisms that promote loose coupling. At last, I'll share with the audience common limitations and pitfalls of GWT.
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.
We will take some sample code and refactor it. As we refactor, we will measure the quality of code using continuous integration. You can pick up a list of refactoring techniques from tools. However, in this section you will learn how and when to drive those tools, and more important why.
NodeJS is quickly picking up steam as a popular and high performance web platform and in this session I'll cover the details on what makes it so fun to work with.
Node.js has been gaining a lot of momentum over the past year, and for good reason! Written atop google's V8 engine with C++ bindings, it makes server-side development simple, easy, and fun. In addition to exploring the details of the platform this session will also give a feel for the the ecology around it.
This talk will introduce you to the Java Message Service, part of the Java Enterprise Edition specification. We'll cover the following topics, lightly interspersed with live coding examples to show the concepts in action:
- Introduction to Messaging
- JMS Message Types
- The JMS API
- JMS Configuration
- Sending and Receiving Messages
- Request/Reply Messaging
- Using Spring's JMS Support
Are you considering migrating off more expensive and heavyweight application servers?
Do you need additional enterprise class server capabilities that Tomcat can’t provide?
Historically stand alone Tomcat requires Administrators to develop a custom framework to handle installations. If configuration changes are required, the management framework has to be expanded to handle these changes for existing instances. Custom installation methods combined with custom management, monitoring and config. methods are time consuming and laborious.
Enterprise Tomcat is here! Join us for a live seminar outlining SpringSource tc Server, an enterprise version of Apache Tomcat. This 1.5 hour seminar will cover tc Server capabilities for:
- Managing large scale deployments
- Controlling distributed groups of
- Tomcat instances
- Deploying enterprise applications reliably to production systems
- Identifying, diagnosing, and resolving server problems quickly and efficiently
Busy developers don't always have time to sit down and read a book from cover to cover. I'll discuss three books that present Java-related concepts in small, easily-digestible chunks.
Reading the books straight through will enlighten you, but picking tips to follow at random will make you a better developer too.
Books covered include:
- Effective Java by Joshua Bloch
- Refactoring: Improving the Design of Existing Code by Martin Fowler
- Practices of an Agile Developer by Venkat Subramaniam
- Bonus book: Groovy in Action by Dierk Koenig
Slides are available at www.crazysmoove.com/memjug/javabooks-slides/javabooks.html
This talk will show you how to run your Java technology-based applications on Google's massive infrastructure.
As always, JavaOne 2009 was a “ginormous event” and it’s completely impossible to take all of it in. I’ll give you the highlights from my perspective and give you the general pulse of where I think the Java community is going.
IT organizations search for greater flexibility to improve business process agility. An agile application and business services portfolio is a key IT deliverable and one of the top focus items for businesses of all sizes. A more stringent regulatory environment drives IT departments to better manage critical business logic and rules, enabling superior business process automation and application and business process audit readiness. Achieving greater agility and transparency leads organizations to improve the modularity and accessibility of their business policies and rules by separating these from business processes and presentation logic into a business rules management system (BRMS).
JBoss Enterprise BRMS provides an open source business rules management system that enables easy business policy and rules development, access, and change management. JBoss Enterprise BRMS includes a fast and highly efficient rule engine and easy to use rules development, management system and repository. JBoss Enterprise BRMS allows businesses to reduce development time to update applications, SOA deployments and business processes with the latest business rules and policies. The JBoss Enterprise BRMS engine implements the full Rete algorithm with high-performance indexing and optimization.
In this session, you will learn about the features and capabilities available with the JBoss Enterprise BRMS and JBoss Enterprise BRMS engine. Additionally, a demonstration of the product will be provided.
The Java Posse Roundup 2011 has come and gone, did you miss it?
An Open Spaces Conference with the Java Posse and Bruce Eckel,
JPR11's theme this year was looking for, and dancing on, the edge.
The taglines included What's New? Where Next? Courage in Software
Engineering. Build vs. Learn. Make sense of it all in this review.
Google AppEngine lets you build and host scalable Web applications
written in Python or Java on Google's infrastructure. We'll look at
how to build and deploy a GWT+GAE application with Google Plugin for
Eclipse and get an overview of building the App Engine way, including
working with the Datastore, task queues, and quotas.
OpenMobster, is a mobile cloud platform for developing Cloud connected Mobile Apps.
These services can be anything ranging from your Corporate backend (CRM, ERP, etc.), to consumer Cloud services (Gmail, Facebook, etc).
Features:
Seamless Data Synchronization: synchronizes and manages the life cycle of locally stored data. This data is then automatically/bidirectionally synchronized with the cloud.
Push Notifications: app state changes are proactively pushed to an App from the Cloud server. The Push mechanism uses a pure network/socket based approach instead of clunky methodologies like sending SMS alerts or email alerts. The Push notifications happen inside the app's execution environment. In case of iOS, Push is based on the Apple Push Notification Service. Supported platforms: Android and iPhone/iOS.
At the talk after an overall introduction to the platform I will show in code how to write an end-to-end Sync App with Push. It will cover the server side components like Sync Channels and Android based client side components.
Project is located at openmobster.googlecode.com
The Open Web Application Security Project has a collection of free tools and projects for tackling security concerns. Some tools covered in the talk include: Mod_sec, an application firewall for webservers to help prevent the top ten risks faced on the web; Netsparker, a semi-free testing tool; and finally Shodan, a site based tool we should all be aware of.
James will introduce the Open Web Application Security Project (OWASP) and will demonstrate tools made available by OWASP for securing web applications.
In 2011 I'll be closely examining three areas that will take me out of my regular comfort zone:
- Functional Programming (Clojure)
- .NET / C#
- NoSQL data stores
I am trying to create a library of libraries for a local credit card process or to help us local Dev guys accept payment without getting paypal or google.
One of the greatest benefits of OSGi is its firewall-esque encapsulation of implementation details. The only traffic that gets in or out is the traffic that you explicitly specify; otherwise, all bets are off. The aspiring polyglot can bring in the right tool for the right job by hiding it behind OSGi services as an “implementation detail,” provided that only Java language types are exported.
This talk will:
- give a brief introduction to OSGi and polyglot programming
- explore the pros and cons of the polyglot OSGi approach
- experiment with Groovy, Clojure, and Scala in an OSGi container
- look at some of the “gotchas” one might encounter along the way
In this talk, I plan to convince you that within the next decade you'll no longer refer to yourself as a Java developer, at least not in terms of the language that you use on a day-to-day basis.
Do your team's agile practices extend to the database? Agile methods are fairly well-understood as they apply to code, but these principles are not commonly understood or practiced on the databases that typically accompany enterprise software projects. Learn the tools, techniques, and mindset your team needs to make incremental improvements to the database’s design over time with confidence.
We'll cover Scott Ambler and Pramod Sadalage's vision of database agility as described in their book Refactoring Databases. We'll discuss the five-pointed constellation of evolutionary design, refactoring, automated testing, source control, and developer sandboxes, and how each of these practices contributes to successful database development. In particular, we'll look at how these practices are enabled by the open-source tool, Liquibase. We'll study a database badly in need of reform, select some refactorings from Ambler's catalog, and implement them in real time in a way that can satisfy the development team and the maybe even the production DBAs! This tool and the practices that animate it produce real results, cleaning up an area of development that is all too often left messy and uncontrolled. If there is a relational database in your life, you will benefit from this talk.
The talk will show how to rapidly build Java-based web applications with Spring 3, Roo, and STS. It will also show how to integrate a little Groovy into your Java development environment, and will feature the new Groovy support in Eclipse!
From whom do you write code? For the compiler? Or for other humans? For whom should you write code? This talk will attempt to answer that question.
All enterprise applications hit bottlenecks as they begin to scale and many times it can be traced to the interaction between the application and the database. Hibernate was designed to easily abstract this interaction from Java developers which has led to it popularity, but in doing so, has caused a rift between developers and database administrators in many organizations. In this session, you will learn how developers and database administrators can work together to break through many application bottlenecks. The topics will include fetching strategies and HQL from the Hibernate side as well as data model and configuration changes from the database side.
Selenium is a suite of tools for testing your web interface directly in a browser. This talk covers Selenium Core, the Selenium IDE Firefox plug-in, the Selenium Remote Control server, and the Selenium Grid. Slides are available at crazysmoove.com/memjug/selenium-slides/selenium.html.
One of the first principles of lean software development is the elimination of waste. Shigeo Shingo identified seven types of manufacturing waste in his "A Study of the Toyota Production System." Later, the Poppendieck's translated these to seven wastes of software development.
The seven wastes:
Partially Done Work
Relearning
Extra Features
Handoffs
Delays
Task Switching
Defects
In this talk, we'll examine each of these wastes and look at some of their common manifestations, both in our coding practices and in our development methodologies. We'll also examine strategies for eliminating each of these wastes from our development efforts.
A brief discussion of the SQLLite DB system.
Everything ‘built’ has flaws. Buildings. Bridges. Software. You name it. But experience reduces the flaws and the risk. And that experience gets applied during architectural reviews, structural reviews and code reviews. Oh yeah, code reviews. Remember those? The benefits are obvious; find the problems early. But implementing reviews remains tricky. What standards? When should they be performed? And, alas, even when done well, their time-consuming nature makes them one of the first items cut from the schedule.
Come hear how a particular type of code review, static analysis, can yield better results. Better accuracy. Better learning. Better results. And static analysis can be automated; a good way to keep it on that project schedule.
Not all JavaScript code written today is tested. For a long time there has been a misconception that JavaScript isnot a "real" programming language, when in fact it actually is a powerful functional language.
This talk will guide the listener through the process of writing clean and tested JavaScript code:
- Brief discussion of separation of concerns (JavaScript, HTML, CSS)
- Setting up our test environment
- Writing some JavaScript, TDD style
- Including our tests in our Continuous Integration build
Please check out the source code at: github.com/shagstrom/testedjs !
The talk draws on examples from architecture and the arts to argue that creative artifacts adhere to a "form" which constrains what kinds of messages they convey. You can't delivery a eulogy in limerick, and you don't sing dirges at weddings. This concept applies to technology, which suggests that we should compare languages and platforms by looking at how they are typically used and what their communities value rather than by running benchmarks. It's difficult to summarize in a paragraph, but the argument ends up being coherent, if not universally accepted.
As an aside, the idea for the talk came from this outstanding book, which has nothing to do with technology, but is worth reading:
In this presentation I'd like to talk about some important programming tips discussed in the following books:
- Programming Pearls (Jon Bentley)
- Practice of Programming (Kernighan and Pike)
- Effective C++ (Scott Meyers)
Google Web Toolkit (GWT) lets you build and optimize rich
browser-based apps without having to be an expert in browser quirks,
XMLHttpRequest, or JavaScript. In this talk, we'll look at powerful
new capabilities in GWT 2.1 including MVP architecture with Activities
and Places, client-server communication with RequestFactory, visual
layout with GWT Designer for Eclipse, and performance optimization
with SpeedTracer.
