~ Chinese Proverb ~
Karel PiwkoDownload slides
Using a web application is easy. Testing it should be easy as well. Arquillian, a revolutionary Java Enterprise testing platform, together with its extensions Arquillian Drone, Arquillian Graphene and Arquillian Android, allows that.
In this session you will learn how to integrate already existing testing frameworks, like JUnit, with web testing tool Selenium in such way that setup can be reused for both test development and in continuous integration tests. Whatever technology are you using to create web pages, wherever is the application deployed and whatever browser including mobile ones are you using, configuring a test environment is a matter of seconds.
Do not spend time with configuration, skip right to writing web tests.
JavaFX is now also available on ARM architecture which opens a completely new field for developers. Due to the reduced capabilities of the ARM architecture compared to standard desktop PC's one have to code in a slightly different way on this kind of machines. Based on the experience developing a JavaFX application for a BeagleBoard xM this session will give you an overview on the possibilities and quirks I came across. But even if the app is based on a developer preview version of JDK 1.7 for ARM it shows repectable results.
Sven PetersDownload slides
Developing a product over years is a tough job. It is hard for the team to stay excited on a day to day basis. So how can you improve motivation and innovation of agile teams and still keep the focus on building a great product?
I want to share with you how we at Atlassian used an agile approach to become one of the most successful developer tool companies in the world. This talk will cover topics like Ship It days, 20-percent time, keeping distraction away from developers, lunchtime talks, dogfooding and much more.
Languages offer a lot more than syntax and compilers. They often have supporting libraries and special facilities that set them apart from other languages. Some languages offer special compiler support for a particular construct, like tail call optimization, for example. Others provide interesting library support or capabilities.
In this presentation we will dive into 12 cool things we can do with different languages on the JVM, things that are either impossible or hard to do in Java, but are quite easy and useful to realize in other popular languages on the JVM. If mixing these languages is an option on your projects, you'll have dozen more reasons after this presentation.
Axel FontaineDownload slides
Your Continuous Integration system is well oiled and kicks in after every commit. Your code is compiled. Your tests are green. You feel ready to take your project to the next level and move to Continuous Delivery.
This transition can be rough and comes with new challenges. We'll look at 5 essential pillars of software architecture that will make it a success: Environment Detection, Auto-Configuration, Database Migrations, Feature Toggles and State Management. By the end of this session you'll have a solid understanding of what it takes to build applications that can be delivered reliably into production multiple times a day, with zero down-time.
The title software architect comes with many connotations, and often these are not good. Developers think of hand-waivers who inhabit ivory towers and have forgotten how to write code. Project managers think of technologists who are chasing perfection in initiatives that are serving obscure technical purposes. Yet, for the success of any software project architecture is crucial. In this talk Erik will present his experience on how to address this issue, introducing techniques that help teams come up with good designs and sustainable architectures without the need for a superstar architect. Topics include evolutionary architecture, the seductive power of abstractions, vertical slicing, software visualisations, and the need to experience the consequences of decisions.
Nilanjan RaychaudhuriDownload slides
Web is evolving and as its evolving it brings out the new challenges for developers:
- How can we build applications that can scale?
- How can we work with multiple data streams?
- How can we build realtime web applications?
In this presentation I will introduce you to new set of abstractions that we developers need to build these modern web applications using Play framework.
Model View Controller isn't just for the server anymore, in fact, many developers utilize those proven ideas inside the browser. Today's rich internet applications leverage client side frameworks and while there are more than you can shake a stick at, Backbone has emerged as one of the leaders of the pack. In this talk, we'll discuss the basics of client Model View Whatever walking you through the ins and outs of using Backbone to build richer, more responsive, interfaces.
Tomek KaczanowskiDownload slides
Writing tests looks simple - every kid could write few lines of JUnit code. :) Writing valuable tests is much more challenging. Everyone have seen (or have written himself!) tests, which are hard to understand, hard to maintain, and do not verify anything really important (or maybe they do, but it is too hard to deduce)! Some tests are simply a burden.
During the talk I plan to present many examples of imperfect tests and show how to improve them. I will discuss typical issues related to writing tests and present techniques which can save our code like parametrized tests, custom asserts, test data builders. The talk is technical, full of useful hints & tips & tricks & dos and & dont's. It also presents few tools (that are not so commonly used). All code examples discussed during the talk are taken from real code.
Pragmatic Java EE best practices look like classic Java anti-patterns and design flaws. This session introduces as many such questionable, but working, patterns and best practices in a continuous hacking style.
We will cover testing, transactions, architecture, concurrency, encapsulation, modularization, productivity, maintainability and as many as possible other “-illities”
Developer’s questions are going to be answered immediately, members of the Ivory Tower will have to wait until the end of the session :-)
JavaFX 2 is shipped with JDK 1.7, supports CSS 3 skinning and powerful data binding. In this session modern MVC/MVP architectures are going to be discussed with focus on JavaFX 8. Especially the impact of WYSIWYG editors (Scene Builder), CSS and data binding on architecture, implementation and testing is going to be presented with lots of code. Integration of REST-services, Java EE 6 integration, long polling and legacy service integration are going to be discussed as well.
The family of HTML5 technologies has pushed the pendulum away from rich client technologies and toward ever-more-capable Web clients running on today’s browsers. In particular, WebSocket brings new opportunities for efficient peer-to-peer communication, providing the basis for a new generation of interactive and “live” Web applications. This session examines the efforts under way with JSR 356 and GlassFish 4 to support WebSocket in the Java programming model, from its base-level integration in the Java Servlet and Java EE containers to a new, easy-to-use API and toolset that are destined to become part of the standard Java platform.
This session will walk you through the details of building great apps for the Android and iOS platforms. We'll talk about Titanium development, its ecosystem, and architecture. We'll spend time looking at lots of code - we'll build an app, in fact, while we discuss and explore the framework. We'll also spend some time discussing best practices, what to expect when developing against it, and the limits of this type of development.
AngularJS is a JS framework created by Google. Thanks to features like dependency injection, two way data binding and strict separation of presentation an business logic it makes it much easier to create large, modular and testable web applications that run in the browser.
History is littered with the stories of iconoclasts--people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes--and their successes and failures. From the baseball management vision of Branch Hickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly.
For an industry that seems so ripe and so rife with "special personalities", it would seem that programming is tied up deeply with iconoclasm. But what defines the iconoclast, what demarcates the "true" iconoclast from the mere pretender, and how can we use the characteristics of the iconoclast to change our own immediate surroundings for the better?
Czego mama nigdy nie mówiła Ci na temat testowania automatycznego - problemy, strategie, taktyki, techniki i narzędzia (Polish)
W ciągu godziny pochylimy się nad typowymi problemami:
- Eksplozja kombinatoryczna przypadków testowych
- Powolne restarty JBossa i żmudne klikanie w ekrany
- Koszt stworzenia i utrzymania testów
- Nieaktualna dokumentacja (nikt jej nie czyta ani nie aktualizuje)
- Problem z komunikacją - brak zrozumienia celów biznesowych, biznes nie rozumie systemu
- Kosztowne w utrzymaniu skrypty do "wyklikania"
- Architektura wspierająca testability (zależności, rozwarstwienie i rygor warstw)
- Delikatne testy (fragile), Nieczytelne testy, Wolne testy przeglądając mniej lub bardziej znane strategie, taktyki, techniki i narzędzia radzenia sobie z tymi problemami.
A przy okazji rozprawimy się z mitami:
- "Konieczność 80+% pokrycia kodu testami" - a może lepiej w 100% przetestować krytyczne 20% kodu?
- "Testy wpływają korzystanie na design" - tak, pod warunkiem, że skill programisty na po pozwala
- "You are not allowed to write a single line of production code until you have written a failing test" - czasem tak, jednak w praktyce: zależy kto, zależy co, zależy jak...
Have you ever heard about Aggregate Roots, Entities, Commands, Events, Event Stores, Sagas, Domain-Driven Design, Command Query Responsibility Segregation, or Event Sourcing? If so, then you probably heard that we don't like frameworks in that world. We like to focus on the actual problems - the Domain. Nevertheless, when we write our systems, we still need some boilerplate code to handle the infrastructure. In Java, the Axon Framework comes to the rescue. Come, and see some examples how to use it, and how it helps concentrating on the Domain.
Architecture isn't just the static "shape" of your software. It's the set of decisions that define it, enabling - or inhibiting - change and improvement over time.
It is also the decisions about how you verify, deploy, version, manage and monitor an application. Each of these decisions is a trade-off: there are no Best Practises. Some decisions can have a huge forward impact, and it isn't always obvious which ones! In this talk Dan offers several strategies to help you improve your architecture decision-making. He won't tell you whether to prefer stability or uncertainty, DRYness or coupling, latency or throughput, manual or automated testing.
That's up to you. But he might help you go into those decisions with your eyes open.
I think by this time we all know certain principles of usability. We’ve all heard the “don’t let the users think” quote – make things obvious and self-explanatory. We should understand the importance if managing users’ attention etc. That’s how our designer friends work on the daily basis, they care for end-users, doing their best to give a pleasant user-experience.
But how this relates to us, backend engineers, whose code never gets nowhere near the frontend layer? It does. Whenever we write a line of code, our peers are the users. Struggling with every single line of code it’s not an experience they’ve been looking for when choosing their career route.
In this session I’ll get through some of the most important usability principles and show how we can reflect them in code. You might say it’s a clean code – true, but taken from a slightly different perspective. We all know the importance of code quality but some rules based on psychology and cognitive principles can give us a better answer to the why questions? Why is that the clean code appeals us.
We are developers. We are creators. We are misunderstood by customers, by managers and even co-workers, we are undervalued and often overworked. People don't appreciate the value we put in our craft and and our drive for innovation. We are central to business in the 21st century yet people don't appreciate us! " Of course you are, but you also forgot to mention: You suck at communication. You often put business at risk based on personal ambitions and waste serious amounts of time trying to improve and discuss the wrong things, all in the name of the next great thing that's going to solve it all. You've completely forgotten the plot! Don't believe me? Why don't you come along to this talk and get a wake up call. But don't expect to be treated nicely.
Mobile devices are becoming an important platform for both customers and employees. But with the range of new devices comes a new challenge. How to support different mobile devices and platforms?
One solution is to build a native app for each device. The downside is that you have to build several copies of the same basic application, and what’s even more important, you have to maintain them.
Mobile web seems to be the best choice for a portable platform, but for the best user-experience you have to use the native environment. Web apps also lose app store as a distribution channel.
Baruch SadogurskyDownload slides
Managing a modern multi-component application in a continuous integration/deployment environment can be very tricky.
In this session we will concentrate on two of the aspects - environment setup, showcasing tools like Vagrant, Chef and Puppet for creating and controlling development, testing, staging, production and other environments and pushing the deliverables through those environments, using tools like Gradle, Jenkins and Artifactory.
Join us and get all the little tips and tricks that will help you rule your development world.
The Raspberry Pi has caused a huge wave of interest amongst developers, providing an ARM powered single board computer running a full Linux distro off an SD card and all for only $35!
This session will look at how Java can be used on a device like this. Oracle recently released an early access preview of JDK8 including JavaFX that is specifically tuned for the Raspberry Pi. Using this release we will show a variety of demonstrations of what the Raspberry Pi is capable of. The Raspberry Pi also provides GPIO line access and we’ll cover how these can be used from Java applications. Prepare to be amazed at what this tiny board can do.
Domain Driven Design promises to simplify enterprise application development and is gradually gaining traction as an alternative to traditional four-tier architectures originally popularized by J2EE. Domain Driven Design embraces Object Oriented Design, Domain Models, Test Driven Development, Agile Refactoring, Continuous Integration, Object Relational Mappers, Dependency Injection, Cross-Cutting Concerns and Layered Architectures.
This session demonstrates first-hand how Domain Driven Design can be implemented using Java EE 6 by seamlessly mapping concepts like bounded contexts, entities, value objects, aggregates, services, repositories and factories to realistic code examples.
Wolf SchlegelDownload slides
Continuous Delivery is addressing the last mile of developing software systems: bringing working software to production in a reliable and repeatable manner. In the first part, the session looks into why Continuous Delivery is important for developers, ops and business people and provides a brief introduction into the ideas behind CD. In the second part, the session covers best practices that help you getting CD Continuous Delivery right.
The next upcoming release of Drools, the 6th, will represent the biggest change since the inception of the project. In fact we decided to drop the backward compatibility with the older releases to accommodate these new features, but in change we have lots to offer like the possibility to package and manage a drools project like a normal maven project and a CDI integration allowing to inject drools sessions and knowledge bases in your classes. Also the Drools Rule Language will have small (like the possibility to define more than a consequence for a given rule) and big (like a better support for functional programming) changes that in general will make the language more powerful and expressive. The purpose of this talk is to give an early preview of these news showing their usage with practical examples.
In the world of increasingly complex software systems, it is vital to control and maintain a rapid development of domain-specific ecosystem, including requirements, dependencies, scripts, tools, domain models, and more, which are part of every single software project. Domain specific languages, languages of a limited expressiveness, can facilitate many of aforesaid challenges.
Eclipse Command Language is a general-purpose scripting language originally developed for Eclipse-based applications, which simply enables advanced scripting and automation. It was initially introduced by Xored at EclipseCon in 2008 and it follows projects such as Eclipse Monkey and Glimmer. One of the main aims of ECL was to enable scripting in Q7 functional testing tool. Presently, ECL as an independent open-source project is a complete Scripting and Automation solution for Eclipse framework and more.
The talk will cover various aspects of DSLs in terms of software engineering, however it will mainly concentrate on presenting Eclipse Command Language in action, as a pragmatic approach to DSLs utilization.
Wojciech SeligaDownload slides
More than year ago we faced the fact that we are hitting the wall with our large scale automated testing in Atlassian JIRA. We analysed the problems and possible solutions and shared them with community at 33rd Degree in 2012. Since then we've implemented a lot of our ideas and come up with new, learnt new quite unexpected things and got rid of Selenium 1 completely.
This session shows the learnings from our journey – escaping from Test Hell – back to the normality.
If you are interested to hear what problems you can (and probably will) face if you have thousands of automated tests on on levels of abstractions (functional, integration, unit, UI, performance) and what solutions can be applied to remedy them – this presentation is for you.
Axel FontaineDownload slides
Database schema evolution is often performed ad-hoc: a quick statement here, a little script there. The result: confusion and uncertainty. Has this update already been applied on this instance? Should we apply this other script first? Is our application going to run against this database?
No more! This is where database migration tools come to the rescue! We'll look at a popular open-source choice called Flyway. By the end of the session, you'll have a solid understanding of what it does, how it works and how to effectively integrate it.
Nilanjan RaychaudhuriDownload slides
Actor based concurrency model is a paradigm shift. What is paradigm shift?
A change in the basic assumptions, or paradigms, within the ruling theory of science. A paradigm shift makes simple ideas hard to grok. Even though Actor model is a simple and revolutionary idea it becomes hard for programmers to see practical benefits and usage. Similarly, the Scala programming language brings a lot to the table in simplifying actor-based design, but comes with a new style of coding. One possible solution to this problem is to evaluate the new paradigm in terms of old paradigm. In this presentation we will take a working Spring based web application and gradually implement it using actors and Scala. We will be skeptical and suspicious of new ideas but at the same time we will be open minded. We will learn about actor based concurrency model using the knowledge of spring. At the same time, we'll learn best practices behind Actors, Scala and combining these with the Spring Framework.
Finally also Java, with its 8th major release, will have lambda expressions and then will allow to employ some functional techniques into its strongly object oriented paradigm. But why this decision has been taken, what will be its consequences, how will it change the way we write Java and, most important, how can we leverage it to develop more expressive, readable, reusable and effective software? After a quick introduction to the syntax of the new lambda expressions, the main purpose of this talk is to answer these questions, showing how functional programming can make us better Java developer and help to avoid or limit some bad habits inherited from our OOP backgroud, like the abuse of side effects, null references and exceptions in our code.
Whether you are just getting started, or you’ve made an attempt and well… it could be better… a lot better, this session is for you. Ken has been working on Agile projects as a coach and mentor for a number of years. Come discover the common reasons teams fail to get it right. Bring your own challenges and lets discuss. This is set to be an engaging and illuminating discussion.
You are getting ready to build a new webapp, but things are different this time. In the past, your number of users was certainly big, but this new app will be five to ten times the size and will need to support not just the browser, but mobile apps and be ready to deploy in both Europe and Asia in six months. Thinking about how you'll hit these requirements, you've started to look into that new area of NoSQL. The options are many, but for the kind of interactive webapp you're looking to build, Couchbase Server looks pretty interesting. For instance, Draw Something scaled their mobile game to 50 million users in 50 days with Couchbase...
Couchbase Server, Open Source under an Apache 2.0 license, is built to be the scale-out data store behind the kinds of applications that want simplified development, high throughput and low latency and may need to scale at a moment's notice. Developers can store either JSON objects or binary data directly into a Couchbase Server cluster and are abstracted away from the details of managing how data is spread across the cluster.
In this session, Tug Grall of Couchbase will provide a quick overview of Couchbase Server and then demonstrate growing a live cluster. He'll then give a quick overview of how simple it is to develop an application for Couchbase, covering the simplified schema-less approach, definition of views using map reduce and use of the Java Couchbase SDKs to access the cluster.
Andres AlmirayDownload slides
Compilers are powerful tools, they pretty much translate your thoughts into machine code. Extensible compilers are even more powerful. It turns out that the Groovy compiler can be extended by means of AST transformations.
Come learn why and how popular Groovy projects like Grails, Griffon and Spock, have reached out to AST transformations and AST manipulation to boost their success. In this talk we’ll dive deep into compiler specifics, by all means bring your laptop if you’d like to hack along.
Nikita Salnikov-TarnovskiDownload slides
Java collections framework is probably the most frequently used Java API. Rarely an algorithm is implemented without using some class from it. But do you really know how much memory that three-element set uses? In this talk we will describe hands-on how memory (in)efficient Java Collection classes are and discuss alternatives to using them.
We will begin by discussing some ways of measuring the memory consumption of different objects and object graphs in Java applications. Next, these techniques will be used to measure how much memory simple objects actually take. While at it, we will explain and discuss object references, memory alignments, integer cache and flyweight objects.
After the discussion of simple objects we will then demonstrate how much memory is really needed in order to accommodate a given amount of data into different structures from Java Collection API.
In the end of the talk we briefly discuss some alternatives to Java Collections, such as Google Guava and Trove and their memory footprint in comparison to standard libraries.
Baruch SadogurskyDownload slides
Taking traditional Java server-side applications to the multi-tenant Cloud introduces lots of challenges. In this session, we will share our experience of creating a SaaS offering, which is currently being used successfully by the Java community.
We will start by reviewing the challenges we faced during the SaaS conversion. Next, we will share our experience with the EC2 platform. We will discuss the importance of automation and how we use tools like Chef and Puppet for SaaS provisioning.
Finally, we will describe how creating a SaaS version of our product shifted our way of thinking about software release. We will recommend what’s required to successfully release both SaaS and downloadable versions of your product.
MapReduce allows systems to delegate the query processing on different machines in parallel. Couchbase 2.0 allows developer to use Map Reduce to query JSON based data on a large volume of data (and server). Couchbase 2.0 features incremental map reduce, which provides powerful aggregates and summaries, even with large datasets for distributed real-time analytic use cases. In this session you will learn:
- What is MapReduce ?
- How incremental map-reduce works in Couchbase Server 2.0?
- How to utilize incremental map-reduce for real-time analytics?
- Common use cases this feature addresses?
In this session you will see in demonstration how you can create new Map Reduce function and use it into your application.
The effort to define the Java EE 7 platform is well underway and the horizons for Java EE 8 are emerging. This session looks into some of the key changes the community can expect. The goal of this session is to foster discussion and participation around these changes.
Some of the changes discussed include cloud support, retiring EJB 2 entity beans and JAX-RPC, greater alignment with CDI, a long-awaited update to the JCache API, WebSocket/HTML 5 support, a standard API for JSON processing, the next version of JAX-RS, an overhaul of JMS, long-awaited concurrency utilities, batch processing in Java EE and much, much more.
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.
Running a software development company is sometimes simple and sometimes complicated. Most often it is really complex and from time to time - very chaotic. Basing on the Cynefin framework (deriving from Complex Adaptive Systems Theory) one can get some guidelines on how to aid decision making and not get lost in the process.
Cynefin is a sense-making framework that describes complex systems (like projects or companies), situations in these systems and aids decision making. It was presented in ‘99 by Dave Snowden and has recently started to get recognition in agile community as it can be used to explain concepts of agility in a broader context. To make it worse (and more geeky) - Cynefin is pronounced in a very unintuitive way.
During the talk I’ll present a few ideas that are rooted in agile concepts (inspection & adaption, collaboration, empowered team, etc.), that have been playtested in a real company and can be reused on any level of an organization (from a project team level up to the whole company as we did).
SmartPhones have revolutionised the way we think and write software: software development on Mobile has and need to be agile ... but how can you make one step further and have actually your SmartPhone to drive your development ?
Can Mobile App development and Continuous Delivery be pushed to the edges?
See how you can follow every step of your development with your SmartPhone end-to-end:
- Continuous Integration
- Continuous Delivery
- Test execution
- Issue tracking
- Production monitoring
Learn how to extend the eco-system by writing your plugins to do even more to shorted your continuous application development, testing and deployment.
The Spock unit testing framework is on the verge of a 1.0 release and has already proven itself to be the next generation thinking on how to test Java production code. One of the many ever present challenges to testing code is the ability to Mock classes which has simplified by Spock from a very early release. Recently added to Spock is the notion of Stubs and Spies. This sessions is designed to demonstrate proper unit testing technique showing off these new features along with a number of advanced Spock features.
Model jest wszystkim czego potrzebujesz (w aplikacjach biznesowych) - czyli czego nauczyłem się w ciągu 5 lat stosowania DDD (Polish)
"Dlaczego ta zmiana kosztuje 100 mandaysów? Przecież chciałem dodać tylko jeden checkbox na ekranie?"
"Ale jaki dług techniczny musimy teraz spłacić? Przecież do tej pory wszystko działało!"
Wszyscy zapewne dobrze znamy tego typu sentencje.
Na domiar złego pojawiają się nowe symptomy: programiści uciekają z organizacji mamrocząc po nosem coś o "big ball of mud" - dziwne, przecież dostali karnet na siłownię...
Podczas prezentacji przedstawię kilkanaście "special hacks" modelowania domen. Niektóre z nich będą oczywiste (choć zwykle nieuświadomione) a inne mniej.
Niektóre mogą być dużymi zmianami a inne drobnymi szczegółami, które jednak robią różnicę.
Zaczniemy podejścia, w którym wspólny model może być stosowany jako narzędzie komunikacji w celu:
- uświadomienia wszystkim złożoności domeny
- zrozumienia kosztów zmian
- świadomego zaciągania długów technicznych
- lepszego rozumienia swojego biznesu przez kleinta
Następnie nazwiemy typowe problemy jakie miewa większość modeli:
- zbytnie uogólnienie
- brak różnienia technik uogólnienia i abstrahowania
- modelowanie tuzinów specjalnych przypadków zamiast znalezienia głębokich reguł
- brak modelu dla złożoności esencjonalnej
- pominięcie modelu czasu
Główna część zostanie poświęcona konkretnym technikom modelowania, które mogą być pomocne na poziomie procesu, na poziomie komunikacji oraz na poziomie architektury i implementacji.
Martin LippertDownload slides
This is a three days event, to work together all the time during conference. Hack, code, regroup every time, here and there.
We are starting on Tuesday, after trainings (18.00) and finish around midnight. We kick off the event with a ringer presentation on what is Open Data and what we can do with it. Please register to give us a feeling how many of you plan to attend.
The kick of will take place in the conference venue: Hotel Gromada Warszawa Airport (ul. 17 Stycznia 32 - Warsaw, Room Agat, Level -1)
Some programmers are simply more effective than others. Kent Beck famously described himself as "not a great programmer, but a good programmer with great habits." Over the last three years Dan has been working with, and observing, some very good programmers with quite exceptional - and rather surprising - habits. Is copy-and-paste always evil? Should you always test-drive production code?
In this talk Dan introduces the idea of programming patterns - patterns of effective programming behaviour - and describes some of the more unusual but effective programming patterns he's been collecting. These are not patterns for beginners, but then again, Dan argues that patterns aren't for beginners anyway.
Andres AlmirayDownload slides
The JVM boasts one of the biggest software ecosystems: you will find libraries, components and servers of all sizes, types, colors and flavors; which have made it the choice language for many. However the JVM is open enough to let other languages live in it, these languages provide new features and concepts that the Java language does not have. On this session we'll discover the benefits of adding a bit of spice to your Java development skills by exploring 3 of the most popular alternative JVM languages.
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. Part of what makes Grails so compelling is its really powerful plugin system. The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others. This session will dive in to that aspect of the framework with a focus on Scala and Clojure and will demonstrate what is involved in adding support for new languages.
Metaprogramming is a key component in building truly dynamic and flexible applications with Groovy. Groovy's metaprogramming capabilities bring great new possibilities to the table that would be very difficult or just plain impossible to write with Java alone. This session will demystify a lot of the magic that seems to be going on inside of a Groovy application. When Java developers are first introduced to Groovy one of the first things they notice is how much easier things are in Groovy compared to Java. Boilerplate code typically generated by your IDE all melts away to nothing in a Groovy bean. Creating XML is a snap, not a tangled mess. File I/O is a breeze. Those developer productivity gains are an important part of the story. However, in addition to making easy the things you are used to doing the hard way Groovy brings whole new capabilities to the party that Java developers don't even think about because you can't do those things with Java. Many of those capabilities are made possible because of the powerful metaprogramming capabilities of the language. Learning the metaprogramming capabilities of the language takes developers the rest of the way to fully taking advantage of the power of Groovy. 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.
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.
After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.
Now that Java is supporting lambda expressions, it's time to hone our skills to make use of them. Lambda expressions can help create concise code, however, it takes more than learning the syntax to put them to good use.
In this presentation we will learn the idiomatic use of lambda expressions, explore the ways in which we can use them to solve common tasks, and look into libraries and APIs that make use of them in Java.
The big language features for Java SE 8 are lambda expressions (closures) and default methods (formerly called defender methods or virtual extension methods). Adding lambda expressions to the language opens up a host of new expressive opportunities for applications and libraries. You might assume that lambda expressions are simply a more syntactically compact form of inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.
This session will explain the ideas behind lambda expressions, how they will be used in Java SE 8 and look at some of the details of their implementation.
Grzegorz BalcerekDownload slides
ScalaCheck is a library for testing software by specifying its properties and automatically verifying them on sets of randomly generated test data. It is inspired by the QuickCheck library which was originally written in Haskell. ScalaCheck is written in the Scala language and runs on the JVM platform.
During the presentation I will introduce ScalaCheck, including:
- defining code properties
- checking these properties on randomly generated test cases
- test parameters
- grouping properties
- generating customized test data
- shrinking (minimizing) test cases
Ratpack is a Groovy-based web framework based on Ruby's Sinatra. It uses a very simple DSL to map web requests to the logic that processes them, drawing on the power of the Groovy API and the entire Java ecosystem in the process. It uses Groovy's SimpleTemplateEngine for an ultra-easy view layer.
Of course a lightweight web app is no good if it's not deployed! Ratpack is ideally suited to cloud deployments in emerging Java cloud platforms like Heroku, Cloud Foundry, and Amazon Elastic Beanstalk. The dream of simple, portable, automated web apps in a high-productivity JVM language is a promising one. Come see how Ratpack is making it a reality.
Anton ArhipovDownload slides
In the dynamic languages it's a given. In .NET the problem is much smaller. But Java EE applications take from 15s up to 10 minutes to build & redeploy, after every change, no matter how small. IDE automate the process, but still require the wait. Why is that and how can it be solved?
JRebel rose as a research project to solve the problem with redeploying the Java applications that led to enormous turnaround cycles. The longer is the turnaround time, the more room for distractions there is, leading to long unintentional breaks and loss of the focus.
Instant turnaround is one of the core attractions of the Play! framework, Grails and Tapestry 5, and some others. In this talk we will review the technical and conceptual challenges involved in solving this issue and the options available today, including the tools mentioned.
We will take a look at the Java ecosystem from the productivity point of view and try to find the ways around the obstacles. How long does your application takes to build? How long does your application server takes to start and deploy the application? Do you have to navigate in the application in order to see the results of your change? We will take a look on how JRebel solves those problems and how it is even possible for the frameworks that aren’t designed for fast turnaround cycles.
Paweł SidorykDownload slides
Riak is an open source, highly scalable, fault-tolerant distributed database. Different than traditional relational databases and other "NoSQL" non-relational databases — Riak offers a number of unique benefits to users:
- Riak is built to operate in highly distributed environments, such as the cloud.
- Riak is master-less; it has no single point of failure.
- Riak is highly fault-tolerant due to its distributed nature. This means you can lose access to many Riak nodes, but never lose data.
- Riak makes data highly available for use in read and write-intensive web applications.
- Riak scales simply and intelligently, simply add a node to a cluster, with no downtime.
- Riak is incredibly stable; many see Riak as the “building blocks” of a cloud data infrastructure.
- Riak’s elegantly simple design makes for a lower cost of operations.
Developing applications on Amazon Web Services (AWS) or moving your business into the cloud is more straightforward than you think. Whether you are a developer eager to learn new skills, a solutions architect who wants to solve existing technology problems, the IT professional who wants access to cost-effective, on-demand computing resources, this session is for you. We give an overview of the AWS platform and show you the Eclipse and Java integration with AWS.
Martin LippertDownload slides
Java is one of the leading programming languages when it comes to enterprise web applications. Thus makes java web apps a target for intrusive attackers and criminal hackers out there.
In this talk I will show you how to find vulnerabilities in your own java web apps using free available tools and how to mitigate them directly in your source code in a short manner of time. The main part of the talk will be focused on context-sensitive exploiting and context-sensitive remedations, because it is most important to know which security methods to use and implement in each shown case.
Tomasz de Jastrzebiec Wykowski
So you’re a manager. Or maybe just want to become one. Or you just wonder how it is to be in ‘managerial position’. This presentation will take you to the roller-coaster of managements do and don’ts. We will look at what typical managers do, what they should do instead and what are the consequences. Don’t expect simple cure-all-wounds solutions, but be prepared for a lot of real-life examples and a spice of fun.
The Single Page App, or SPA, require the developer thinks about architecture in new ways compared to traditional server-side page generation web apps. Whether you've used Java web frameworks like Spring Web, or Struts, dynamic frameworks like Grails or Rails, or even Django or PHP, you will need to learn some new techniques for building SPA type applications. We discuss the architecture and design of Service Oriented Front End Architectures (SOFEA) in this session.
In this session, we'll look at structuring your app from both the client and server side. Using a SPA framework like Backbone.js or Ember can help, but does not answer critical design questions. This is a fast paced session where we'll talk about SPAs, REST, SEO, and much more.
"SOAP sucks, it's the root of all evil…" some may say. Whether we like it or not, however, a lot of endpoints still exists - live and kicking!
There is a plethora of Java frameworks supporting SOAP but most of them follow the paradigm of the explicit or implicit code (stubs) generation. Handy as it may seem at the beginning, it can also be redundant and cumbersome. After the 8 long years of having Web-Services on the JVM almost nothing has changed in the way we use them… Why do we still blindly follow the same (anti)patterns?
This session will be a critical whirlwind tour of SOAP Web-Services reviewing the existing solutions and emphasizing some of the biggest drawbacks of the frameworks based on the code generation. It will rethink the idea of Java Web-Services refuting widely-accepted concepts that nobody reflects on anymore. It will also offer people handy tools to overcome common problems (like endpoint versioning) and prevent them from following bad practices.
On the example of soap-ws, project authored by me, a completly different approach will be presented. soap-ws provides a lightweight Java Web-Services stack (based on Spring-WS) that handles the SOAP protocol "codelessly" on a purely XML level, adding a bit of Groovy flavor on the top of it! Using soap-ws enables handy generation, transmission and handling of SOAP messages without the usage of stubs, no matter what style the WS client and server are.
Do you want to consume and expose a fully-functional SOAP service in 10 minutes in runtime? Do you want to learn how to properly unit test SOAP endpoints? Or maybe you simply want to have some fun? Don't miss this talk mate!
Software quality has an obvious external aspect, the software should be of value to its users, but there is also a more elusive internal aspect to quality, to do with the clarity of the design, the ease with which we as technologists can understand, extend, and maintain the software. When pressed for a definition, this is where we usually end up saying “I know it when I see it.” But how can we see quality? This session explains how visualisation concepts can be applied at the right level to present meaningful information about quality. Different visualizations allow us to spot patterns, trends, and outliers. In short, they allow us to see the quality of our software. The tools and techniques shown are easy to apply on software projects and will guide the development team towards producing higher quality software.
Data exchanges in and between companies increase a lot. The number of applications which must be integrated increases, too. As solution, an Enterprise Service Bus (ESB) can be used in almost every integration project - no matter which technologies, transport protocols, data formats, or environments such as Java or .NET are used. All integration projects can be realized in a consistent way without redundant boilerplate code.
However, an ESB offers many further features, such as business process management (BPM), master data management, business activity monitoring, or big data. Plenty of ESB products are on the market which differ a lot regarding concepts, programming models, tooling, and open source vs. proprietary. Really one is spoilt for choice.
This session shows and compares ESB alternatives and discusses their pros and cons. Besides, a recommendation will be given when to use just a lightweight framework for a specific problem such as systems integration or BPM instead of a (too) powerful ESB.
Oliver GierkeDownload slides
The repository abstraction layer is one of the core pieces of the Spring Data projects. It provides a consistent, interface-based programming model to allow implementing data access layers easily. The talk will start with a brief introduction and dive into best practices and implementation patterns later one.
We will conclude the session with an overview over what can actually be built on top of this generic repository abstraction and discuss integration hooks into Spring MVC and REST webservices.
Katrin HipplerDownload slides
Numerous highly skilled professional providers on Elance, and other work platforms, start working on the platform as freelancers, but end up running their own business.
One of the key reasons for being able to expand from freelancer to a business is that they consistently deliver high quality work, earn a good reputation on the platform and win so many jobs that they can either subcontract the work to other Elancers or hire a team locally.
This talk will focus on subjects like:
- How to become successful on online work platforms
- What the opportunities for developers are
- Advises on how to move from a freelancer to a business owner with on-site and online team members
- Key statistics on the online work market
- Case study on a local freelancer that has been highly successful as an online freelancer
Let me present you the most pleasant and modern way to test your Android application.
Android testing support brought the ability to run tests on a device. The Robolectric you are able to run your test suite fast, without the need of any deployments. With some glue work we brought the beauty of the Spock testing framework for Groovy to the Robolectric crazy classloaders world and now we're using it on a daily basis.
Come and see why you're about to drop JUnit and start loving TDD.
Metaprogramming is the dirty little secret behind the success of many Java frameworks such as Spring and Struts2, and forms the backbone of many of the most fundamental APIs across the JEE technology stack. This session aims to introduce the topic and highlight, with code examples, the different mechanisms and techniques to take advantage of this underused feature of the Java Programming Language. This session will adopt a learn-by-example approach that combines the philosophy and theory behind metaprogramming with concrete code examples. No previous knowledge or exposure to the topic is required, but an intermediate understanding of Java SE is expected.
Tight deadlines, budgets on a strict diet, exploding metrics KLOC, CC, RFC, nebulas of technologies, paradigms, and manifestos. Distributed teams, „nonsense” large and complex systems.
In the times of global financial crisis, are we also witnessing (and can also be culprits), the crisis in our industry? Crisis, which has a much further forward consequences.
During the presentation we will try to understand what is a crisis of architecture, what are its sources and consequences. We will try to see beyond our „garden” and seek solutions using „systems thinking” and „complexity theory”. We will look at the archetypes of systems, and will try to understand what characterises „complex systems” and hopefully will propose solutions to the problems we are facing today. Instead of the reading lines of code, trying to understand the intentions of the author, we can improve our system, by understanding its structure and interactions between components. We will take a look at „systems” outside of software development world and will find many similarities. Why resilient, self-organizing and hierarchical systems are most common and stable systems in an outside world. What we can learn from it?
Maybe instead of studying programming languages, platforms and architecture styles and patterns we should focus on understanding how systems work in general? Understand nature of systems and their complexity.
During our career, most of us started out with a language or a platform and spearheaded the evaluation and adoption of a totally different language, platform or even a paradigm. What is interesting is that once (at least significant number of) these programmers make that switch, they tend to settle down and unwilling to make the next move. This happens quite frequently in a number of software communities. In this keynote, award winning author, programmer, and mentor Dr. Venkat Subramaniam will draw parallels to empires in our civilizations and programming languages. There are lessons for us to learn as language designers and programmers on how to cope and benefit with the rise and fall of languages during the exhilarating ride through our careers.
The rise of NoSQL is characterized with confusion and ambiguity; very much like any fast-emerging organic movement in the absence of well-defined standards and adequate software solutions. Whether you are a developer or an architect, many questions come to mind when faced with the decision of where your data should be stored and how it should be managed. The following are some of these questions: What does the rise of all these NoSQL technologies mean to my enterprise? What is NoSQL to begin with? Does it mean "No SQL"? Could this be just another fad? Is it a good idea to bet the future of my enterprise on these new exotic technologies and simply abandon proven mature Relational DataBase Management Systems (RDBMS)? How scalable is scalable? Assuming that I am sold, how do I choose the one that fit my needs best? Is there a middle ground somewhere? What is this Polyglot Persistence I hear about? The answers to these questions and many more is the subject of this talk along with a survey of the most popular of NoSQL technologies. Be there or be square.
Grzegorz BorkowskiDownload slides
Java has always had poor track record of date and time handling. The core classes: java.util.Date and Calendar are awkward to use and poorly designed. What is worse, even experienced programmers are not aware of many problems which can be caused by inappropriate usage of these classes; and often they don't know how to correctly handle time zones and how to deal with DST (Daylight Saving Time).
The good news is that we are going to have a completely new, better API for date and time handling in Java 8. The bad news is that instead of two basic classes (Date and Calendar) from the old JDK, the new API will contain dozens of classes for modelling different concepts related to date and time - so it's high time for you to come and learn how to use them!
Relational databases have ruled the world since the dawn of time (or so it appears). They power our enterprises and for many in the corporate world, it may be hard to imagine life without them. Each decade a novel idea would challenge the status quo and make a case to deviate for the tradition. A flock of enthusiastic programmers, like your humble speaker back in the early 90s, would throw their support around it, only to be crushed eventually by the large vendors and enterprise standards. But, the excitement around NoSQL has shown that enterprise data is not the only thing that's persistent.
In this presentation we'll learn how NoSQL deviates from those deep rooted traditional approaches, and how this may be useful. We will also discuss the situations where these types of databases may be more appropriate.
We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2 this will be taken to a whole new level with its “Distributed by Design”. Akka 2 provides location transparency by abstracting away both these tangents of scalability by turning them into an operations and configuration task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication and partitioning. In this talk you will learn what Akka is and how it can be used to solve hard scalability problems. Akka is available at http://akka.io (under Apache 2 license).
This session explains the key concepts of the server-side and client-side RIA development with Java as well as summarizes what is new with Vaadin 7 and how it relates to GWT. To demonstrate the use of the framework, an example application is developed during the session step-by-step. The presentation is concluded with pointers on how to start developing your own applications with Apache-licensed Vaadin 7.
Oliver GierkeDownload slides
If applications grow bigger, modularity becomes a key aspect regarding maintainability. Design decisions made in the early days are hardly discoverable in the codebase, inter-module dependencies grow a lot. The talk introduces means and approaches to connect logical architecture to the codebase. Beyond that we discuss patterns and best practices around general code organization, package structures to build a solid foundation for Java applications and in how far Spring can help creating loosely coupled components and dedicated points to extend applications.
Co to są aplikacje wielojęzyczne? Jakie wzorce projektowe można stosować przy ich realizacji? Na te pytania odpowie Marek Berkan podczas swojego wykładu. Zaprezentuje aspekty techniczne lokalizacji: po stronie serwera oraz związane z interfejsem użytkownika.
Bazując na doświadczeniach z projektu wdrożonego w 29 krajach Europy w 26 językach, opowie o rozwiązaniach organizacyjnych, które przy dużych aplikacjach mogą stać się większym wyzwaniem niż problemy technologiczne. Marek opisze także kilka ciekawych kwestii specyficznych dla różnych krajów.
Michał BartyzelDownload slides
Domain-Driven Design, Test-Driven Development, Behavior-Driven Development, Data-Driven Design, Data-Driven Development, Use Case-Driven Design, Use Case-Driven Design, Architecture-Driven Design, Architecture-Driven Development, Model-Driven Development, Agile Model-Driven Development i tak dalej i tak dalej...
Czy coś ci to przypomina? Mnie tak. Kiedyś mówiliśmy ze znudzeniem "$%!@ yet another framework!". Teraz trzeba powiedzieć z tym samym znudzeniem: "%$!@ yet another mental framework!".
W trakcie prezentacji chcę pokazać, w jaki sposób pogoń za kolejnymi x-Driven Design, y-Driven Development wypacza to, co jest naprawdę ważne w programowaniu czyli umiejętność rozwiązywania problemów. Zajmiemy się również dość ważnym pytaniem: jaka jest właściwie relacja wszystkich tych "mental frameworks" do rzeczywistości, z którą spotykamy się na co dzień.
Kai WähnerDownload slides
Big data represents a significant paradigm shift in enterprise technology. Big data radically changes the nature of the data management profession as it introduces new concerns about the volume, velocity and variety of corporate data.
This session goes beyond the well-known examples of huge companies such as Facebook or Google with millions of users. Instead, this session explains the "big" paradigm and technology shift for your company. See several use cases how big data enables small / medium-sized companies to gain insight into new business opportunities (and threats) and how big data stands to transform much of what the modern enterprise is today.
Learn about solving the unique challenges of big data without an own research lab or several big data experts in your company. Learn how to implement the relevant use cases for your company with low costs and efforts by using open source frameworks, which simplify working with big data a lot.
Anton ArhipovDownload slides
Which IDE do you use? Eclipse? NetBeans? IntelliJ IDEA? Visual Studio? Vim? Yeah, Vim counts as an IDE too if you can configure it to behave like one! Do you leverage the full power of your favourite IDE/editor?
Generally, developers _just use_ the IDE and every so often do not utilize the power of automated refactorings, shortcuts, fast navigation and other awesome features that IDEs provide. Modern IDEs have revolutionized the way in which we are able to work with the code. Using the IDE is a skill and this skill can be turned into a habit. The habit can be good or bad and we will discuss the common patterns in how developers use the IDE.
In this session we will take a look at the features of various IDEs that you cannot live without. We'll start with navigation features, proceed with quick edit tips & tricks, and lead to cross-functional features of the IDEs by leveraging the power of plugin system. I will demo my favourite features in IntelliJ IDEA and I hope you can learn something new from this session.
Gerrit code review is the popular Git and collaboration tool that allows thousands of developers and companies to work together for the Android OS development and most of the Eclipse projects.
Gerrit is now easier, more powerful and extensible to be able to integrate the Code Review into your Team Agile Project lifecycle.
See in actions some popular plugins for GitBlit, Git branch network and Atlassian Jira.
Martin LippertDownload slides
The Eclipse-based tooling for Spring has undergo a major restructuring in 2012. Since version 3.0 the famous Spring Tool Suite is now completely restructured, fully open-source, and available at GitHub under an EPL license. This talk explains the changes and restructuring the tool suite went through, and highlights new features for Spring developers. It also provides a look behind the scenes and explains the agile development process and the project rhythm of the development team behind the tool suites from SpringSource/VMware. A brief outlook about what to expect in 2013 will conclude this session.
Nikita Salnikov-TarnovskiDownload slides
We are a young company developing memory-leak monitoring product called Plumbr. All the members of our development team have 10+ years of experience in developing Java EE projects. But when we founded our own company, we faced various surprises, unexpected problems and totally new experiences. In this session we share the details of the journey of Java EE developers whose daily routines suddenly converted to low-level JVM programming in the unknown land of product development.
We start off by providing background info of the team and the product we develop. Then we review some of the most interesting problems that we have encountered. For each problem we will present some possible solutions and the rationale behind our choice:
- How to track objects’ creation and disposal events? Bytecode instrumentation and the classes that cannot be instrumented. A problem of locking and overhead on objects allocation rate.
- How to conduct graph analysis in a memory scarce environment. The problems of already existing libraries and APIs and why we ended up implementing the basic graph algorithm one more time ourselves.
- User iteration and desktop integration from a Java agent. Who is RMI Reaper and how to decide when you need to commit suicide.
In this talk you get to see the ins and outs of a fresh company and can have a peek under the hood of what kind of technical problems a young company faces in its daily life.
Tim BerglundDownload slides
No matter what version control system you're using right now, you owe it to yourself to learn about Git. Git's distributed nature and free hosting available at GitHub.com change the source control game in a number of ways.
Bring your laptop (with Git installed!) and come to this workshop to learn how to use Git to track changes to your source code, view history, create and merge branches, and share code in online repositories like GitHub.com.
This 3 hours workshop will allow you to discover the basis of NoSQL Document oriented databases. This hands-on lab will drive you through the key concepts NoSQL document databases
- JSON Documents
- Key/Value databases
- Map Reduce
- Cluster Elasticity
You will learn how to install and configure Couchbase Server 2.0 and use your favorite language (Java, or other…) to create your first -or not- NoSQL application.
If you want you will also learn how to integrate full text search into your application using the Couchbase Elastic Search plugin.
Couchbase Servver is easy to install on Linux, OS X or Windows so "Come as you are"
- 4Mb of RAM
- Java 6 (or 7, but 6 is better)
- Maven 3
- Ideally you can also have downloaded Couchbase 2.0
Amazon Web Services Solution Architect
During this 2h workshop, we will discuss architecture best practices on how to build production systems on Amazon Web Services. To illustrate those concepts, we will build a scalable and reliable video sharing website using multiple services such as Amazon EC2, Auto Scaling, Amazon CloudFront, Amazon CloudSearch, Amazon DynamoDB, and Amazon Elastic Transcoding.
This workshop is ideal for technical professionals who want to have a better understanding on how to build advanced architectures on AWS.
- Attendees should bring their own laptop (with full administrator rights)
- Attendees should have a good understanding of Amazon Web Services (see: http://aws.amazon.com/)
- Attendees should have a working Amazon Web Services account
Formula 1 drivers don’t just drive faster than you, they drive differently. Accelerated Agile practitioners use different rules, based on the core principles of agile but taken to another level, to deliver in hours and days what regular teams can only achieve in weeks or months.
Accelerated Agile is a course for experienced agile practitioners who are frustrated with the pseudo-science of agile planning and estimation, the social pressure to automate where it doesn’t add any value, the artificial commitment of sprints and the unwelcome surprises that still derail their projects. You will learn new techniques that both enhance and replace existing agile practices, some of which are counter-intuitive and many which are completely counter to current Agile doctrine. This is not a course for beginners!
Using a mixture of discussion, instruction and exploration you will learn new techniques for development and testing, operations, automation and team dynamics. Using these techniques you and your teams will deliver business solutions faster than they thought possible. You’ll never look at TDD the same way again, not to mention copying-and-pasting code.
What you will learn
- How to challenge the received wisdom of established Agile methods
- How to design and architect for rapid and sustainable delivery
- Why understanding risk and embracing uncertainty are at the heart of faster delivery
- How to manage build, release and operations
- How systems thinking can help you plan effectively and estimate accurately
- How to identify and reduce gaps in your testing strategy
- How to engage with legacy systems and integrating with third parties
- How to manage different levels of skill and experience within a team
Praise for Accelerated Agile
“one of the best courses I have ever attended, if not the best!”
“really interesting with good discussions and lots of relevant information”
“[not using slides] made the course flow in a neat and agile way”
More details at http://dannorth.net/courses/accelerated-agile/
11th - 12th March 2013
2490 PLN (700 EUR) + 23% VAT
Tomasz de Jastrzebiec Wykowski
Scrum is the best known Agile methodology, allowing for effective IT project management. It let you see what's really happening in your project, deliver value to your product incrementally and get feedback faster.
Scrum changes the way of managing IT projects. Moving away from the traditional, formal management, it emphasizes self organization of the team. Therefore, Scrum Team no longer needs typical project manager, and his place is filled with two new roles - Scrum Master and Product Owner.
This two-day, advanced Certified ScrumMaster training prepares participants for the ScrumMaster role. Through interactive exercises they learn Scrum principles and how to efficiently apply them to lead and empower Agile team. Certified Scrum Trainer presents advanced Scrum topics, such as multi-team organizations and explains how to handle challenges the Scrum project encounters.
Training covers the following topics presented through intensive exercises, lectures and discussions:
- Team Agreements
- Silent Sort exercise
- The Ball Points Game
Lean, Agile, and Scrum
- Scrum Process exercise
- Sprint types exercise
Scrum Master Role
- Working with the team
- Change agent in an organization
- Leadership and organizational aspects of implementing Scrum
Product Owner Role
- Working with stakeholders
- Responsibilities and expectations
- Ideal Product Owner exercise
- Timeline retrospective exercise
- The Knot: a self organization simulation
- Team attributes, model of formation
- Common issues for ScrumMasters
Product Backlog, User Stories and Agile requirements
- User story writing exercise
Agile Estimating and Planning
- Agile estimating
- Storypoints exercise
- Planning Poker exercise
What is “Done?”
- Definition-of-Done exercise
Q & A
The course goal is to prepare participants for the ScrumMaster role in their projects. After completing the training they will be able to:
- Utilize Scrum tools to lead a Scrum Team,
- Plan, monitor and report progress in Scrum projects,
- Identify roles and responsibilities in a Scrum Team,
- Remove impediments between Product Owner, stakeholders and the team to maximize ROI for developed product,
- Ensure commitment, encourage self-organization and support team members,
- Continuously improve the software development process, engineering practices and tools used.
Upon completion of the course, attendees are eligible to take the Certified ScrumMaster exam, the successful completion of which results in the designation of "Certified ScrumMaster" from the Scrum Alliance.
Participants of Certified ScrumMaster training are eligible for 14 PDUs.
Certified ScrumMaster training is intended for members of software development project teams: programmers, testers, analytics, managers, and all other individuals interested in extending their knowledge about Agile and Scrum.
Basic knowledge about Agile and software project management is recommended, but not a must. The list of suggested reading for Scrum can be found on Scrum Alliance web page.
Podczas warsztatu przejdziemy przez wszystkie fazy procesu modelowania
- Modeling Whirlpool - poznając jednocześnie kolejne techniki DDD:
- po czym poznać, że warto zainwestować czas w modelowanie
- rola modelu: rozumienie złożoności, rozumienie kosztów zmian, świadome zaciąganie długów technicznych
2. Burza mózgów - do tanga trzeba dwojga: Eksperta Domenowego i Modelarza
- techniki komunikacji
- techniki przełamywania impasu w sesjach modelowania
3. Scenariusz referencyjny - modelowanie wymagań
W fazie Scenariuszy Referencyjnych i Wyzwania poznamy narzędzia służące do sporządzania wykonywalnych (jako testy akceptacyjne) specyfikacji: JBehave i Selenium
4. Modelowanie - główny etap, połączony z decyzjami architektonicznymi
Wstęp do Wzorców Strategicznych
- domain distilation
- bounded context
W fazie modelowania będziemy posługiwać się technikami z zakresu Wzorców Taktycznych DDD:
- rozwarstwienie logiki na Aplikacyjną i Domenową
- 4 poziomy modelu Domenowego
- building blocks: Encje, Agregaty, Value Objects, Factory, Repository, Policy, Specification, Domain Event
- typowe problemy i najlepsze praktyki stosowania building blocks
5. Wyzwanie - sprawdzenie punktów swobody modelu
6. Próba - zakodowanie chodzącego szkieletu
W fazie Próby zostaną wskazane techniczne konsekwencja stosowania proponowanych technik:
- zwiększenie testability - podatności systemu na testy automatyczne
- otwarcie designu na rozbudowę
- skrócenie czasu developmentu poprzez redukcję czasu pracy z serwerem aplikacji i bazy danych
Spring Data is an 'umbrella' project, developed by SpringSource community, which easies development of applications while working with different database models. From relational databases over "good old" JDBC, through O/R mappings with a little bit of help from JPA, to hottest and newest NoSQL databases, which span from key-value, document to graph databases.
Spring Data simplifies connectivity with variety of databases, provides unified programming model and patterns.It also frees you from writing boilerplate code by promoting convention over coding and extensive use of runtime generated code. Thanks to this you can focus on building valid and complete domain models with less annoying errors in your data access layer, which results in higher quality code delivered in less time.
During this two day training you will get familiar with four different data models, including O/R mappings (JPA 2.0), key-value stores (Redis), document databases (MongoDB) and graph databases (Neo4j). You will understand how Spring Data works undercover, and how different data models fit into modern web applications and how to work "polyglot persistance" concept.
During this heavy "hands on" training you will work with web application which will be refactored over time to use Spring Data and different databases. We will also discuss prons and cons of different data models, and design forces which can lead you to use one or the other. We will also learn how to work with type-safe JPA queries, Spring Data in JEE 6 applications and everything you want to know about data and were afraid to ask.
- Notebook with JDK 6, Maven and favorite IDE installed
- Solid experience in Java Programming, including object-oriented Java
- Some experience with Java EE development, especially Web applications using servlets, will be very helpful, but is not strictly required
- Some understanding of XML and XML Schema is strongly recommended
Dla osób, które od pewnego czasu są lub dopiero staną się liderami zespołów realizujących projekty programistyczne. Wiele cennych informacji odnajdą również doświadczeni liderzy, którzy szukają odpowiedzi na konkretne pytania związane ze swoją rolą i jeszcze jej nie znalazły. A przede wszystkim dla tych, którzy chcą wypracować taki styl przywództwa, w którym członkowie zespołu podążają za liderem i są wysoce zmotywowani. Zapraszamy Liderów Technicznych, Kierowników Zespołów i osoby, które będą pełnić rolę Lidera lub Kierownika w przyszłości.
Dlaczego to szkolenie?
Ścieżka kariery w obszarze IT jest nietypowa. Jej początek zaczyna się od stanowiska inżynierskiego, potem zostaje się seniorem, by w końcu zostać liderem lub kierownikiem. W efekcie osoba o przygotowaniu stricte technicznym staje przed nie lada wyzwaniem poprowadzenia grupy ludzi bez wcześniejszego przygotowania do tej roli. Są tacy, którzy posiadają niesamowitą intuicję i im się udaje. Są jednak w mniejszości. Pozostałe osoby zmagając się z codziennością, próbują stawić czoła wyzwaniu. Szkolenie „Technical Leadership” ma na celu uzupełnić tę lukę – nabycia lub wyszlifowania umiejętności poprowadzenia zespołu do zwycięstwa. Nie jest to jednak typowe szkolenie z przywództwa, gdyż jesteśmy świadomi, że inżynierowie wymagają odmiennego podejścia. Ponieważ sami przeszliśmy tę drogę, odpowiednio dobraliśmy narzędzia, porównania, metafory i przykłady.
Korzyści płynące ze szkolenia
- Stworzysz plan własnego rozwoju, aby małymi krokami budować postawę inspirującego lidera;
- Będziesz wiedział jak współdzielić obowiązki lidera z pracami technicznymi;
- Stworzysz strategię budowania relacji między zespołem a klientem/pozostałą częścią organizacji;
- Poznasz niezawodne sposoby motywowania siebie, tak aby działać niezachwiania w każdej sytuacji;
- Będziesz potrafił zrozumieć i zmotywować osoby w zespole, szczególnie te uważane za trudne;
- Będzie potrafił wypracować strategię wprowadzania złożonych zmian;
- Będziesz potrafił przeprowadzić zespół przez trudne zmiany;
- Szybko i skutecznie będziesz potrafił porozumieć się z innymi i odnajdować intencje, którymi się kierują.
Najważniejsze pytania, na które padną odpowiedzi
Jaki jest twój styl przywódczy i jak go najlepiej wykorzystać? Co możesz wykorzystać z innych stylów przywódczych? Jak zbudować swój własny styl i jak wdrożyć plan jego rozwoju? Jak odnaleźć się w innej roli? Jak znaleźć złoty środek między obowiązkami technicznymi i koordynacją pracy? Jak zapanować nad ogromem różnych zadań i informacji? Jaką relację stworzyć z zespołem i resztą firmy? Jak to zrobić? Jak promować sukcesy zespołu? Jak budować swoją własną markę? Jak odnaleźć to co Cię motywuje i to co Cię powstrzymuje? Jak wykorzystać stres i własne mocne strony w motywacji? Jak wzbudzić w sobie stan „nie do powstrzymania”? Jak pomagać innym nie pomagając? Co możesz zrobić z użytkiem pytań? Na czym polega sztuka doceniania? Dobry pomysł nie wystarczy, trzeba jeszcze mieć strategię wprowadzenia zmiany – jak to zrobić? Jak przekonać zespół? Jak przekonać innych poza zespołem? Jak poprowadzić rozmowę, aby szybko doprowadziła do celu? Co jest ważne a co mniej ważne? Jakie pytania zadawać i w jakim momencie? Jak efektywnie prowadzić spotkania?
1. Rola lidera technicznego
- Czym jest Technical Leadership?
- Style przywódcze
- Plan rozwoju umiejętności przywódczych
- Nowy układ relacji Ty-zespół-organizacja
- Ale ja dziś prawie nic nie zrobiłem - jak godzić prace techniczne i koordynację prac innych?
- Jak znaleźć czas na przygotowanie się do nowej roli?
- Jak nadać sens wykonywanym dodatkowym czynnościom? (dokumentacja, uczestnictwo w spotkaniach, wypełnianie raportów)?
2. Motywacja własna
- Główne przeszkody
- Rola i rozwijanie samoświadomości
- Jak wzbudzić w sobie siłę nie do powstrzymania
- Wizja - dlaczego bez wizji nie ma przywództwa.
- Wprowadzanie wizji w życie
3. Motywowanie innych
- Dlaczego motywowanie jest trudne?
- Dlaczego inni nie chcą, żeby im pomagać?
- Jak uczyć się motywowania?
- Co napędza do działania?
- Kultywowanie stanu lidera
- Dbanie o rozwój innych
- Budowanie swojej marki w organizacji
- Korzystanie z zasobów organizacji
- Tworzenie i rozwijanie efektywnego zespołu
5. Kompetencje lidera
- Umiejętność przeprowadzania przez zmiany techniczne i organizacyjne
- Organizacja pracy własnej
- Prowadzenie efektywnych spotkań
- Jak dogadywać się? - rozwiązywanie konfliktów
- O co ci naprawdę chodzi? - znajdowanie intencji rozmówcy
- The Ball Points Game