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.
Topics
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.
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.
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.
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.
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.
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.
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.
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)
