1. Angular for Java developers
2. Continuous performance
– load testing for developers with Gatling
1. Front-end development has evolved
massively. New tools, libraries and frameworks are released every
day. But how do you keep up with this as a Java developer? Which
frameworks should you learn, and where do you get started?
Angular is without doubt one of the most popular
frameworks for building modern web front-ends. And most of its
concepts are not that far off from everything we now from the
Java world. Take TypeScript for example - you now can write proper
typed code in the browser!
In this fast-paced session, I'm sharing my experience as a Java
developer with developing Angular applications. I'll explain all
about tools like npm, RxJS, Sass, Karma, Protractor and compare
them to their counterparts in the Java ecosystem. I'll start with
an empty IDE and live code my way to a working Angular application
connected to a Spring Boot backend, sharing lots of tips, insights
After this session, you'll know enough about Angular to get started
2. Performance testing is traditionally a task
for specialists that takes place at the very end of the software
delivery life cycle. But how does this fit in with a DevOps way
of working, where continuous feedback is one of the key points?
It doesn't. In a world where scalability and performance are just
as important as delivering new features, you need to embed performance
testing in your daily development workflow: it needs to become
a natural part of development. And this is where Gatling comes
in: an open source load testing framework based on Scala, Akka
and Netty. In this session, you will learn how to use Gatling
to incorporate performance testing in development and how to provide
your team with continuous feedback on your application's performance.
Subjects include an introduction to Gatling, automated recording
and processing of performance tests with the Gatling Scala DSL
and integration with Jenkins for automated execution, bench marking
and reporting of load tests.
Live Refactoring Session:
Getting rid of dirty code
In this live hacking, we will look at three typical
starting situations for refactoring dirty code. In the first example,
we will wade through rotten code: an untested, miserably long,
unmaintainable method without any test coverage. In the second
code example, it gets a little better. The method is still too
long and barely maintainable, but it has some rudimentary test
coverage. In the third code example, we look at a method that
is fully covered by tests and is free of simple warnings, yet
that has deeper structural problems that cannot be solved quickly.
In this live coding you get practical advice on how to master
a refactoring step by step - even in difficult situations.