Design Patterns Training in Christchurch

This instructor-led, live training in Christchurch (online or onsite) is designed for intermediate-level Java developers who want to apply design patterns to enhance software structure, maintainability, and scalability.

By the end of this training, participants will be able to:

• Understand the purpose and benefits of design patterns.
• Effectively apply Creational, Structural, and Behavioural patterns in Java.
• Improve code reusability, scalability, and maintainability.
• Refactor existing codebases using design patterns.

The evolution of microservices and containers in recent years has significantly transformed how we design, develop, deploy, and operate software. Modern applications must be optimised for scalability, elasticity, resilience to failure, and adaptability to change. Driven by these evolving demands, contemporary architectures require a distinct set of patterns and practices. In this training, we explore ways to identify, understand, and adapt to these new requirements.

Audience
This training is designed for individuals who are already somewhat familiar with container technology and Kubernetes concepts but may lack hands-on, real-world experience. Grounded in real-world use cases and lessons learned from actual projects, the course aims to inspire participants to create and manage even better cloud-native applications.

• Developers
• Operations
• DevOps
• QA Engineers
• IT Project Managers

Course Format

• Interactive lectures and discussions
• Abundant exercises and practical practice
• Hands-on implementation in a live-lab environment

Course Customisation Options

• To request a customised version of this training, please contact us to arrange.

There is a wealth of proven patterns readily accessible to everyone. Often, it simply involves adapting the nomenclature and implementing the pattern within a specific technology. This approach can save countless hours that would otherwise be dedicated to design and testing. The goals of this training are twofold: first, it empowers you to leverage widely recognised patterns; second, it enables you to create and reuse patterns tailored to your organisation. It assists you in estimating how patterns can reduce costs, systematise the design process, and generate a code framework based on your patterns. The intended audience includes software designers, business analysts, project managers, programmers and developers, as well as operational managers and software division managers. The course style centres on use cases and their relationship with specific patterns. Most examples are explained using UML and simple Java examples (the language may change if the course is booked as a closed course). It guides you through the origins of patterns and demonstrates how to catalogue and describe patterns that can be reused across your organisation.

Target audience:

Technical Team Leaders, Software Developers

Learning objective:

The aim of this training is to develop the ability to design advanced development and project structures in C#.

Throughout the course, participants will become familiar with MSDN resources and tools that support the development process, such as Microsoft Visual Studio and ReSharper.

This instructor-led, live training in Christchurch (online or on-site) is designed for intermediate-level PHP developers who want to apply design patterns effectively in their projects.

By the end of this training, participants will be able to:

• Understand the purpose and benefits of design patterns.
• Identify and implement appropriate design patterns for common scenarios.
• Structure PHP applications using industry-recognised best practices.
• Integrate patterns into modern frameworks such as Symfony or Zend.

This training is designed for JavaScript developers responsible for designing and implementing advanced web applications. The topics covered aim to introduce best practices in JavaScript programming and highlight common pitfalls. A key focus of the course is exploring object-oriented programming concepts within JavaScript syntax.

Kubernetes is an open-source platform for automating all development stages of containerised applications. Design patterns are iterative solutions to software development problems relevant to software design. Kubernetes extensions are used to configure and support Kubernetes clusters. With the aid of Kubernetes design patterns and extensions, platform users can implement CI/CD approaches while maintaining the scalability and flexibility of their software applications.

This instructor-led, live training (delivered online or on-site) is designed for developers and DevOps engineers who wish to leverage Kubernetes design patterns and extensions to build enterprise applications on Kubernetes clusters.

By the end of this training, participants will be able to:

• Set up a Kubernetes cluster and configure the necessary DevOps tools.
• Understand the fundamentals of software design patterns and Kubernetes extensions.
• Utilise Kubernetes extensions and design patterns when interacting with the Kubernetes API.
• Develop custom Kubernetes resources and apply dynamic controllers to a cluster.
• Manage and secure any Kubernetes environment with the help of Kubernetes plugins.
• Integrate DevOps networking models into existing and prospective Kubernetes projects.

Course Format

• Interactive lectures and discussions.
• Abundant exercises and practice opportunities.
• Hands-on implementation in a live-lab environment.

Course Customisation Options

• To request a customised training session for this course, please contact us to arrange.

Microservice architecture is an approach to developing a software application as a suite of small, independent services, each running in its own process and communicating via lightweight mechanisms such as an HTTP resource API. These services can be efficiently deployed using continuous automation systems, eliminating the need for centralised management. Microservices can be written in different programming languages and integrate with diverse data storage systems.

This instructor-led, live training is designed for enterprise developers and architects. It introduces microservice architecture from a .Net perspective, outlines migration strategies from monolithic systems, and guides participants through creating and deploying a sample microservice-based application.

By the end of this training, participants will be able to:

• Understand when to use and when not to use microservice architecture
• Create and implement a testing strategy for microservices
• Deploy a sample microservice-based application into a production environment
• Refactor a monolithic application into services

Audience

• Developers
• Architects

Course format

• Part lecture, part discussion, with exercises and extensive hands-on practice

Objective:

To assist Technical Analysts and Designers in understanding how to implement software requirements, ensuring clear traceability between business specifications and the resulting code.

This two-day training course supports technical analysts and designers in interpreting specifications provided by business analysts. Once transformed into software component representations, the resulting system components maintain traceability from system requirements down to software component structures.

Ultimately, these technical specifications are implemented in code and tested at the component level. The resulting software components offer a high degree of responsiveness to change, enabling traceability of system behaviours layer by layer—from user interfaces through application components (where user choices are captured) down to the business objects layer.

This course is designed for experienced programmers who wish to explore key issues related to the use of design patterns and refactoring. Each participant will gain an understanding of the properties and practical examples of applying these patterns, enabling them to build and correct application code efficiently.

With the emergence of highly complex distributed systems, the complexity once confined to a single system has shifted to the architecture of the entire group of systems. This course explores the relationship between Software Architecture and Technical Enterprise Architecture. These two domains are interrelated in ways that are not yet clearly articulated. For instance, breaking down a complex monolithic system into two systems that communicate via web services will trigger significant changes to both the new systems and the architecture that connects them.

This course will examine the trade-offs, commonly used patterns, and established solutions for managing complex systems and their communication, both within and across system boundaries.