Command/query responsibility separation (CQRS) and Event Sourcing are two complementary systems design patterns that have been common practice for years in some software communities, but Java developers are just now taking notice in large numbers. This presentation will introduce the patterns in natural progression as certain requirements in apps drive the need for certain architectural patterns, as well as highlighting the complexities in building microservices.
Andrew Stakhov is a professional software architect with a passion for technology specializing in the .NET stack, Microsoft ecosystem and public cloud offerings. He has an innate obsession for code excellence and spends much of his time figuring out how to apply the best of breed technologies to accomplish not just immediate project goals, but also align with long-term company objectives. Currently, he works as a Platform Architect at Pivotal where he helps to enable clients with the right skills and tools to be successful. This includes running proofs-of-concept, delivering workshops, and assisting with strategic planning on cloud transformation journey many are set on.
Java 11 came out this week. It is the first Long-Term Support (LTS) release of Java since Java 8, which according to a show of hands at last month's Meetup, you are probably still using.
The LTS status means Java 11 is likely to be the next version you adopt. Are you ready? Is your IDE ready? Will your frameworks run under Java 11? What's new in this release anyway?
At this month's JUG, we intend to find out together in a group-directed live coding session (aka Mob Programming).
Join us as we learn, laugh, and muddle through it together.
The presentation today will highlight some of the new features in Java 7, 8 and 9 that added in the Third Edition of Effective Java.
Thulasi is an Agile Engineer at Helpful. She has been developing in Java and Spring Boot for almost two years. Her curiosity and interest in developing her Java fundamental knowledge has lead her to this book.
Over the course of the past decade, there has been a shift in how a lot of development in general, and most open source development in particular is done. Starting with the introduction of Github, and now the ecosystem of services that have grown around it, many of the supporting services around development work are now handled by software that's "in the cloud".
This talk will demonstrate setting up a simple open source project with a source code repository, continuous integration, test coverage metrics, and more.
Angelo is a software developer at Street Contxt working primarily on distributed streaming systems. He’s been working in Scala for 5 years and java for over a decade.
Since it’s introduction over 20 years ago, Java developers have had plenty of strong and often opposing ways of doing things.
Modern day JVM development has only added more options, more divisiveness, and even more heated arguments.
* Constructor or Setter Injection ?
* Dynamic or Static typing ?
* Monolithic or Micro-service application design ?
* Java or Scala or Kotlin ?
* JVM or .NET ?
* Reactive ?
* Are Mutable types and Threads inherently Evil?
* Is Kubernetes / Docker the modern way of JVM deployments?
Let’s dive into these and other issues .. while also stepping back and looking at the Bigger Picture:
What is it really about these choices that improve the bottom line ?
Most importantly .. let’s also settle once and for all:
Maven or Gradle?
Victor's been programming since he was 10 and building Java apps since version 1.4. In his past he’s taught Java at SAIT Polytechnic in Calgary, and traveled the world as a consultant for ThoughtWorks doing various Agile’y and DevOps things. Currently he works at Pivotal as a Platform Architect.
In his spare time he likes skiing, and cooking with his InstantPot — though not necessarily at the same time.
This talk is all about the problems / patterns / and techniques that you can use to refactor a monolith towards Microservices. We start with a demo of a monolithic application then we review its architecture and technology stack used. We then proceed through a series of obstacles to refactoring this app along with the patterns that are required to overcome the obstacles. This talk is aimed at developers and architects looking to learn techniques for refactoring the monolith.
About the speaker
Adib Saikali is a long-time user of Java and Spring. He is a Field Engineer at Pivotal.
This talk will delve into lessons learned from developing and managing secure Java applications at scale. We'll cover topics of configuring and managing TLS, performance considerations for cryptographic functions, patching and more.
In this session, I’ll highlight the easiest ways for Java developers to deliver their code to the cloud and the best ways to reliably make updates and maintain production cloud code.
The focus will be on real-world examples with working demos using Linux command line tools, VMs, Docker, Kubernetes, serverless functions, SaaS, Maven, open source tools such as Jenkins, and other free SDKs and tools available on GitHub.
The examples, tools and demos that I show will be applicable to any cloud platform, and all are available on GitHub. I will show Microsoft Azure running the samples but will not be selling azure - this is a technical talk that will focus on the code.
About the Speaker
Brian Benz is a Senior Cloud Developer Advocate at Microsoft, helping Java developers to get the most out of Azure. Before Joining Microsoft, he was a solution architect, consultant, developer, author and presenter at IBM, Deloitte, and other companies. Find him on Twitter @bbenz
Static diagrams on wikis and white-boards might capture the vision of architects, but they don’t much help programmers to understand how the code they’re working on right now fits into the architecture. Nor are the programmers warned when they violate the diagrams as they forge changes, line-by-line. This is a huge problem – it is ultimately individual lines of code that make or break an architecture; and we know that a clean architecture will help teams develop a more flexible product, with less complexity, less wasted effort, etc. Worse, without practical architectural guidance, programmers wrestle with invisible structures that emerge from thousands of inter-dependent lines of code. And being invisible, these structures become ever more complex, coupled, and tangled. In fact, uncontrolled structure actively fights against productive development.
This talk shows how to rein in emergent code-base structures and gradually transform them into a cogent, defined architecture. You will see how…
• Visualizing the emergent structure makes a code-base easier to understand.
• Restructuring to remove tangles and reduce coupling makes the visualized code-base easier to work on.
• Specifying layering and dependency rules converts good structure into a controlled architecture that guides the team as the code-base evolves and grows. A key ingredient is a live visualization, inside the IDE, of the detailed code the programmer is working on, in the context of the overall architecture.
In short, you will learn how bridging the architect/programmer divide can convert code-base structure from liability into an asset that actively works for development productivity.
About The Presenter
Ross McNamara hails from the Canadian Maritimes, and graduated from the University of New Brunswick's Computer Engineering program in 1987. Since then Ross has worked in all phases of Software Engineering, from implementation and unit testing to large scale architectural design and program management. Ross has experience in diverse systems domains including aerospace (avionics and International Space Station Canadarm2 programs), financial infrastructure and IP/telecommunications solutions. Ross joined Headway Software to focus on improving day-to-day enterprise scale software engineering practice by providing real-world, pragmatic Structure101workflow solutions.
Ross resides with his wife and two daughters in Burlington, Ontario. His primary hobby is convincing the family to go boating on Lake Ontario in the summer and hiking the local trails in winter.
Introduction to Android Development
An introduction to the Android ecosystem and Android development. The basics of putting together an Android app, introduction to Android Studio, current trends in Android development and app design considerations.
About the speaker:
Todd Burgess is an Android developer who has been doing Android app development for 3 years.
Note on the recent topic change for the January meeting:
Many thanks to Todd for stepping up with a replacement topic topic for this month! The originally scheduled topic will be presented at a future TJUG meeting. Apologies for the late notice.