People from the following companies attended my courses:
Description
Security by design is a fundamental approach, nowadays every Java developer should implicitly consider it while writing any piece of code, even though it might or might not be an explicit quality attribute.
This course reveals key concepts, principles, and approaches that are used to design applications where security is a first-class quality attribute. Upon completion, you’ll have a thorough understanding of security principles that you can apply to your project.
Key concepts covered in this course
- Security design principles (e.g. least privilege, defense in depth, minimization, compartmentalization, simplicity, fail securely, etc)
- OAuth 2.0 grant types
- Implicit Flow
- Password Grant
- Client Credentials
- Authorization Code
- Refresh/access tokens
- APIs (micro)services security
- Token introspection
-
JSON Web Key Set (JWKS)
-
Permissions based access control
-
JWT vulnerabilities (e.g. “alg”: “none”)
- Java process security
-
Input data sanitization techniques
-
Dealing with input files from external sources
-
Whitelisting vs. blacklisting approach
-
Efficient logging patterns
-
Randomly generated numbers
-
Java serialization
- JVM Security Manager
-
- Mitigating attacks
- SQL injection
- XML external entity
- DoS via input data
-
Docker containers security
Duration
- 12 hours
Target Audience
- Java developers
- application security geeks
- technical leaders
- software architects
People from the following companies attended my courses:
Enroll
Note: At the moment this course is available only for companies, teams, or groups of students. The individual subscription (i.e. single person) is not an option at the moment.
Description
The goal of the course is to outline key concepts, principles and approaches used to design applications where high-performance, scalability, and resiliency are first-class quality attributes.
By the end of this course, the candidates will have acquired in-depth knowledge about how to design, implement high-performance, scalable, and resilient applications, and how to create a proper testing plan.
Key concepts covered in this course
- Different metrics are used to quantify performance, scalability, and resilience, such as response time, latency, throughput, percentiles, availability, etc.
- Architectural tactics and patterns to support high-performance, scalability, and resiliency (e.g. synchronous vs asynchronous, data push vs. data pull, caching, circuit breaker, bulkheads, back pressure, throttling, etc.)
- Modern architectural styles that might be used while designing high-performance, scalable, and resilient applications, with their pros and cons (e.g. microservices, event-driven, event-sourcing, reactive, serverless, lambda, etc.).
- Networking assets used to complement the architectural styles (e.g. API Gateway, load balancer, service discovery, content delivery network)
- Advanced high-performance development techniques such as NUMA, large pages, C-states, CPU Governors, RamFS/TmpFS, SSD I/O Scheduler, Kernel TCP Buffers, etc.
- How to elaborate a test plan with a focus on load testing
Agenda
- Architectural concepts pertaining to high-performance, scalable, and resilient applications. Quality attributes metrics
- Architectural tactics, patterns, and styles for high-performance, scalability, and resiliency
- Advanced performance optimizations techniques
- Application load testing
- Examples of modern systems (e.g. Linkedin use case, etc.)
Duration
- 16 hours
Target Audience
- software developers
- technical leaders
- software/solution architects
- test engineers
- business analysts with a technical background or passionate about technology
Attendees’ Feedback
[su_quote]Excellent course content helping me to understand a lot of things, from a very high level and abstract to a very deep and technical perspective.[/su_quote]
[su_quote]I recommend this course if you want to get in touch with real technical topics. The trainer clearly explained to them, even for less technical people.[/su_quote]
[su_quote]The trainer was very well prepared. He answered all of our questions, even if they were not really the subject of the training.[/su_quote]
[su_quote]I liked more the advanced part about how to tune an application, outside of the programming language, to get better performance.[/su_quote]
[su_quote]Interesting and informative course, presented by a trainer who knows a lot of stuff. I got a lot of ideas and techniques that I can use to build more efficient applications in my daily job.[/su_quote]
People from the following companies attended my courses:
Enroll
Note: At the moment this course is available only for companies, teams, or groups of students. The individual subscription (i.e. single person) is not an option at the moment.
Description
- The course introduces the main concepts and context of software architecture. Participants will learn about practices such as essential requirements identification, architectural design, architectural documentation, and architecture analysis.
- It provides a clear understanding of the main aspects of being a software architect, as well as different types of architects (e.g. enterprise, solution, software, and system).
- It reveals a structured way of collecting and documenting the business requirements with an architectural impact (i.e. non-functional requirements) to be quantifiable, measurable, and testable.
- It includes various design techniques in light of the Quality Attributes which help to create software architecture.
- It teaches you how to create proper and structured architectural documentation, in compliance with its purpose and beneficiaries (i.e. users).
- Evaluating software architecture should be part of each project, hence we will discuss different techniques that might help you to mitigate the architectural risk.
- It gives a recipe to conduct a healthy evaluation across different frameworks and libraries which might fit the project, to pick up the most suitable and appropriate based on the environmental context.
- The course is a blend of lectures, individual and team exercises, and interactive workshops.
Agenda
- Main architectural concepts (e.g. what is a software architecture, the contexts of software architecture, the architecture influence cycle, etc.). The duties, skills, and knowledge of a software architect
- Stakeholders, Business Goals and Quality Attributes (e.g. scalability, performance, security, availability, modifiability) in lights of architectural tactics
- Designing software architecture
- Documenting the software architecture via viewpoint-based approach and architectural views (how to structure the architectural description)
- Evaluation of the software architecture involving different types of stakeholders
- Technologies and frameworks from an architectural perspective (what they mean and how to properly choose them)
Duration
- 16 hours
Target Audience
- software developers
- technical leaders
- software/solution architects
- test engineers
- business analysts with a technical background or passionate about technology
Attendees’ Feedback
[su_quote]I liked the structure of the course, the fact that we applied the concepts we learned by following a methodology creating an architecture starting from the requirements.[/su_quote]
[su_quote]The course helped me understand the architectural concepts and the role of an architect.[/su_quote]
[su_quote]The course helped me to learn the terminology better, by doing exercises, also with book recommendations, describing architectural tactics and generic patterns.[/su_quote]
[su_quote]I was clarified regarding the diagrams (views and viewpoints) and regarding the applicability of some quality attributes.[/su_quote]
[su_quote]The trainer is a true professional. He explained everything in detail as best as he could.[/su_quote]
[su_quote]I think that diagrams are most useful. I think that they should be implemented for every project and presented to developers when they see a project for the first time, as it is easier to imagine and understand how a project works.[/su_quote]
People from the following companies attended my courses:
Enroll
Note: At the moment this course is available only for companies, teams, or groups of students. The individual subscription (i.e. single person) is not an option at the moment.
Description
- In this course, the attendees will learn how to develop Java software applications with performance as a first-class quality attribute.
- The course is an intensive training targeting passionate Java software developers who are looking to expand their knowledge to discover how to write better code, profile, and tune Java applications.
- It covers topics like JVM architecture, runtime execution engine, memory structure, garbage collectors, JVM tuning and profiling, analyzing case studies from a performance standpoint, and revealing performance code best practices (tips and tricks).
- The course is a blend of lectures, code samples analysis, and profiling and tuning case studies.
Agenda
- Java Virtual Machine Architecture
- ClassLoader, [Dynamic][Application] Class Data Sharing
- Execution Engine (e.g. Interpreter, Just In Time Compiler, Ahead of Time Compiler)
- Java Memory Structure (e.g. Stack, Heap, Metaspace, Code Cache, Direct Memory)
- Java Garbage Collections (e.g. Serial GC, Parallel GC, G1 GC, ZGC, Shenandoah GC, Epsilon GC)
- Garbage Collection Friendly Programming Tips & Tricks
- JVM Tuning
- JVM Profiling
- Performance Friendly Programming Tips & Tricks
Duration
- 16 hours
Target Audience
- Java developers
- JVM performance geeks
- technical leaders
- software architects
Attendees’ Feedback
[su_quote]I managed to understand how the JVM and the garbage collector works, I learned to do profiling for applications, I understood how the memory works and I received some tips and tricks to improve myself as a programmer. Overall this training is very useful.[/su_quote]
[su_quote]This has been the best course in the Java area I ever attended. The trainer was more than qualified, he organized the course so that it would be easy for attendees of any level, to understand the basic concepts behind the subject.[/su_quote]
[su_quote]A lot of useful information about the JVM. All this information can be used in my daily programming activity. Also, I learned new tools that will help me to troubleshoot memory issues in the future.[/su_quote]
[su_quote]The training was awesome. It covered things that people don’t usually learn about, but are useful, like JVM internals. The most useful for me was the profiling techniques in the context of all the other JVM internal explanations.[/su_quote]
[su_quote]Excellent training, the instructor is very knowledgeable and well-prepared, and has visibly put a lot of effort into organizing the course and creating the course materials.[/su_quote]
People from the following companies attended my courses:
Enroll
Note: At the moment this course is available only for companies, teams, or groups of students. The individual subscription (i.e. single person) is not an option at the moment.
Java Performance Tuning
This course covers JVM architecture, memory structure, Garbage Collectors, tuning, profiling, micro-benchmarking techniques, tips, and tricks.
Duration: 16 h
Software Architecture Essentials
This course introduces the main concepts and context of software architecture, roles, and responsibilities of a software architect, essential requirements identification, architectural design techniques, how to properly document and review the architecture.
Duration: 16 h
Designing High-Performance, Scalable, and Resilient Applications
The goal of the course is to outline key concepts, principles, and approaches used to design applications where high-performance, scalability, and resiliency are first-class quality attributes.
Duration: 16 h
Application Security for Java Developers
This course reveals key concepts, principles, and approaches that are used to design applications where security is a first-class quality attribute.
Duration: 12 h