Design Patterns Training in Belgrade

This instructor-led, live training in Belgrade (online or onsite) is designed for intermediate Java developers seeking to apply design patterns to improve software structure, maintainability, and scalability.

Upon completion of this training, participants will be able to:

• Grasp the purpose and advantages of using design patterns.
• Effectively apply Creational, Structural, and Behavioral patterns in Java.
• Enhance code reusability, scalability, and maintainability.
• Refactor existing codebases by employing design patterns.

The rapid evolution of microservices and container technologies in recent years has fundamentally transformed the way software is designed, developed, deployed, and operated. Modern applications need to be optimized for scalability, elasticity, fault tolerance, and adaptability. To meet these evolving demands, contemporary architectures require a distinct set of patterns and best practices. This training explores methods for identifying, understanding, and adapting to these new requirements.

Audience
This course is designed for professionals who possess a foundational knowledge of container technology and Kubernetes concepts but may lack hands-on, real-world experience. It draws on use cases and lessons learned from actual projects, aiming to inspire participants to design and manage superior cloud-native applications.

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

Course Format

• Interactive lectures and discussions
• Extensive exercises and practical work
• Hands-on implementation within a live-lab environment

Customization Options

• For requests regarding customized training for this course, please contact us to arrange details.

Numerous proven patterns are readily accessible to everyone. Often, the key lies in adapting their names and applying them within a specific technology. This approach can save hundreds of hours that would otherwise be devoted to design and testing phases. Training Goals This course has two primary goals: first, it enables you to reuse well-established patterns, and second, it empowers you to create and reuse patterns tailored to your organization. It helps you estimate how patterns can reduce costs, systematize the design process, and generate a code framework based on your patterns. Audience Software designers, business analysts, project managers, programmers, and developers, as well as operational managers and software division managers. Course Style The course focuses on use cases and their relationship with a specific pattern. Most of the examples are explained in UML and in simple Java examples (the language can change if the course is booked as a closed course). It guides you through the sources of the patterns as well as showing you how to catalogue and describe patterns which can be reused across your organization.

Target audience:

Technical Team Leaders, Software Developers

Learning objectives:

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

During 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 Belgrade (online or onsite) is aimed at intermediate-level PHP developers who wish 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-recognized best practices.
• Integrate patterns into modern frameworks such as Symfony or Zend.

This training is tailored for JavaScript developers focused on designing and implementing sophisticated Internet applications. The curriculum emphasizes best practices in JavaScript programming while addressing common pitfalls. A key objective is to explore object-oriented programming concepts within the context of JavaScript syntax.

Kubernetes serves as an open-source platform designed to automate the entire lifecycle of containerized application development. Design patterns offer proven, repeatable solutions to common software development challenges, particularly those related to system architecture. Meanwhile, Kubernetes extensions are employed to configure and enhance the capabilities of Kubernetes clusters. By leveraging these design patterns and extensions, users can implement Continuous Integration and Continuous Deployment (CI/CD) strategies while preserving the scalability and flexibility required by modern software applications.

This instructor-led live training, available both online and on-site, targets developers and DevOps engineers aiming to harness Kubernetes design patterns and extensions to build enterprise-grade applications on Kubernetes clusters.

Upon completion of this training, participants will be equipped to:

• Configure a Kubernetes cluster alongside the essential DevOps tooling.
• Grasp the core principles behind software design patterns and Kubernetes extensions.
• Effectively use Kubernetes extensions and design patterns when engaging with the Kubernetes API.
• Create custom Kubernetes resources and deploy dynamic controllers within a cluster.
• Securely manage and protect any Kubernetes environment using Kubernetes plugins.
• Incorporate DevOps networking models into current and future Kubernetes initiatives.

Course Format

• Interactive lectures and group discussions.
• Extensive exercises and practical application.
• Hands-on implementation within a live laboratory environment.

Course Customization Options

• For customized training requests, please contact us to discuss arrangements.

A microservice architecture represents a methodology for building software applications as a collection of loosely coupled, small-scale services. Each service operates within its own process and communicates via lightweight mechanisms, such as HTTP REST APIs. This approach allows for efficient deployment through continuous automation tools, eliminating the necessity for centralized management. Additionally, microservices can be developed using various programming languages and connected to diverse data storage solutions.

Facilitated by an instructor, this live training targets enterprise developers and architects. It offers a perspective on microservice architecture from a .Net standpoint, explores strategies for migrating from monolithic systems, and guides participants through the development and deployment of a sample microservice-based application.

Upon completion of this training, participants will be capable of:

• Evaluating the appropriate scenarios for adopting or avoiding microservice architecture
• Developing and executing a testing strategy tailored for microservices
• Deploying a sample microservice-based application into a production environment
• Refactoring a monolithic application into distinct services

Target Audience

• Developers
• Architects

Course Format

• A combination of lectures, discussions, exercises, and extensive hands-on practice

Objective:

The primary goal is to empower Technical Analysts and Designers with the knowledge to navigate the software implementation of requirements, ensuring a clear traceability link between business specifications and the final software code.

This two-day training course is designed to assist technical analysts and designers in crafting specifications that accurately reflect those defined by business analysts. Once transformed into representations of software components, the resulting system components establish a traceable path from system requirements down to the software component structures.

Ultimately, these technical specifications are translated into software code and tested on a component-by-component basis. The resulting software components offer a high degree of reactivity to changes, enabling separate tracing of system behaviors layer by layer—from user interfaces through business object layers to application components, where the usage choices of actors are documented.

This course is tailored for experienced programmers looking to dive into the challenges and benefits of applying design patterns and refactoring techniques. Participants will learn the core principles of these patterns, supported by practical examples, empowering them to write efficient, correct, and maintainable application code.

As distributed systems become increasingly complex, the challenge shifts from the intricacies of individual systems to the complexity of their overall architectural structure. This course explores the intricate relationship between Software Architecture and Technical Enterprise Architecture, two domains that are closely linked yet often lack clear description in current practices. For instance, decomposing a complex monolithic system into two separate systems that communicate via web services necessitates significant modifications to both the new systems and the architecture facilitating their interaction.

This course will examine the trade-offs involved, as well as commonly used patterns and solutions for managing complex systems and the communication flows within and between them.