1. Internal Developer Platform
2. “One Data Hub” and tokenization. Distribution of data downstream.
   1. On what comes first: Analytical or Operations data.
3. concentrate on Application Design aspects of cloud. Less Infrastructure.
   1. example serverless application
      1. on java-native
         1. project structure for gradle
         2. deployment to multi-region
         3. routing
         4. api GW for lambdas
      2. database? DynamoDB Global?
      3. add CQRS
   2. various clouds
   3. K8s and CloudNativeFoundation
   4. Serverless
   5. Containers
   6. Business logic and Mesh
   7. Aspects like Streaming, consistency, liveness.
4. Event-sourcing architecture on AWS
   1. learn https://developer.axoniq.io/en/axon-server/overview
      1. https://www.baeldung.com/axon-cqrs-event-sourcing
   2. Principles and Patterns, implement with services, cost and scalability
      1. Pattern: https://www.martinfowler.com/eaaDev/DomainEvent.html
      2. Principles: how it relates to well arch framework
      3. Principle: Space Decoupling / Location Transparency: service discovery
      4. Principle: Time Decoupling: async message delivery
      5. Principle: non blocking I/O operations for efficiency. Idempotent operations. Reactor pattern. see https://stackoverflow.com/questions/9138294/what-is-the-difference-between-event-driven-model-and-reactor-pattern
   3. Services: https://aws.amazon.com/de/blogs/architecture/reactive-microservices-architecture-on-aws/
5. Compare some popular CI/CD - GitLab, CodePipeline, Fastlane, analyze flows like here: https://www.linkedin.com/pulse/fast-lane-aws-pipelines-roman-naumenko/

1. Service isolation, for resource/limit/operational isolation (need to know)
   1. in K8s or
   2. using Accounts as units (service per account)

1. Archimate https://pubs.opengroup.org/architecture/archimate3-doc/ch-Application-Layer.html
2. Cloud Patterns on Azure - https://docs.microsoft.com/en-us/azure/architecture/patterns/
3. Archimate
4. Vaughn Vernon - Implementing Domain-Driven Design - 2013
   1. Event Sourcing
   2. DDD
   3. Domain events
   4. “Event Storming” technique
5. Architecture Patterns https://en.wikipedia.org/wiki/Architectural_pattern
   1. ETL - Extract-Transform-Load
   2. S.O.L.I.D principle https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
      1. enables loose coupling of modules

* LocalAI:

• Description: LocalAI is a fantastic open-source, free, and self-hosted alternative to OpenAI, providing a drop-in replacement REST API for local inference. It supports a wide range of models, including GGUF, and can pull models from various sources, including OCI registries (like Ollama's OCI registry) and Hugging Face.
• How to get it: You typically run LocalAI itself within a Docker container.

docker run -ti –name local-ai -p 8080:8080 localai/localai:latest

   (Use a GPU-specific image like localai/localai:latest-gpu-nvidia-cuda-12 if you have an NVIDIA GPU).
 * Usage: Once LocalAI is running, you can interact with it via its OpenAI-compatible API (e.g., using curl or Python's openai library with base_url pointed to LocalAI). You can tell LocalAI to pull models directly from an OCI URI, for example:
   local-ai run ollama://gemma:2b

• Pros: Very flexible, supports many model types and backends, provides an OpenAI-compatible API, robust community.
• Cons: Requires running a separate LocalAI container, might be overkill if you just want simple CLI interaction.

* Ollama:

• Description: Ollama is another popular, free, and open-source tool designed specifically for running LLMs locally. It's incredibly user-friendly and handles much of the complexity (like GGUF conversion, quantization, and OCI packaging) behind the scenes. While it uses its own “Ollama registry,” it effectively packages GGUF models in an OCI-like fashion.
• How to get it: Ollama provides a simple installation script for Linux:

curl -fsSL https://ollama.com/install.sh | sh

• Usage:
  • To pull and run a model: ollama run gemma:2b
  • Ollama also exposes an API at http://localhost:11434 which is becoming a widely adopted standard for local LLM APIs.
• Pros: Extremely easy to use, handles all GGUF and OCI packaging complexities, growing model library, good community support, CLI and API.
• Cons: While it uses OCI principles for distribution, it operates with its own specific “Ollama” model names rather than direct generic OCI registry paths for models.

* RamaLama:

• Description: RamaLama is an open-source tool that aims to simplify the local serving of AI models from various sources, including OCI Container Registries, using familiar container concepts (Docker/Podman). It automates the detection of your system's GPU support and pulls appropriate OCI images.
• How to get it: It's a command-line tool, likely installed from source or pre-built binaries, and relies on a container engine (Docker or Podman) being present.
• Pros: Focus on container-native workflow, handles GPU detection, supports multiple AI model registries.
• Cons: Newer project, might not have as extensive a feature set or community as llama.cpp derivatives or Ollama yet.

Key considerations when choosing: * Ease of Use: If you want the simplest experience, Ollama is hard to beat. * Flexibility & Control: LocalAI offers a high degree of flexibility with its API and support for various backends.

1. docker model runner https://habr.com/ru/articles/898778/
2. https://www.youtube.com/watch?v=zt4lSwx3ybw Access Control collection
3. Google Mandiant and Nozomi
   1. https://cloud.google.com/security/products/threat-intelligence#how-it-works
4. Firewall
   1. Checkpoint
   2. WAF
   3. Azure Firewall https://www.udemy.com/course/checkpoint-firewall-r81/?couponCode=LETSLEARNNOW
5. Azure
   1. EntraId
      1. K8s project https://swisscard.udemy.com/course/microservices-with-spring-boot-and-spring-cloud/
      2. integrate app with EntraId
   2. API-Manager
   3. Service Bus (Amazon SNS)
   4. integrate with Event Hubs (Amazon Kinesis)
   5. Data Driven services, Synapse Workspaces, ETL etc. Building a Data Warehouse.
6. Kubernetes project on the PI
7. “Service-Mash” und K8s. With Spring-Boot.
   1. Istio and SPring Boot micro-services
   2. K8s Rancher
8. camunda bpm

1. Cloud native Java-stack
   1. 
   2. https://tafadzwalnyamukapa.medium.com/spring-boot-3-spring-native-graalvm-with-kubernetes-istio-c26687185366
2. security certifications (ISO2700x, SOC 2)
3. security automation (SAST/DAST)
4. DDD book
   1. Problem Domain - hello w
   2. Solution Domain - hello w
   3. Take by example “DropBox” https://medium.com/nick-tune-tech-strategy-blog/domains-subdomain-problem-solution-space-in-ddd-clearly-defined-e0b49c7b586c
5. https://en.wikipedia.org/wiki/Self-contained_system_(software)

1. Kafka / Azure Message Hub
2. Kubernetis
3. Docker tools http://www.midvision.com/blog/10-open-source-docker-tools-you-should-be-using
4. all in https://landscape.cncf.io/
5. all in https://www.thoughtworks.com/de-de/radar

1. http://bost.ocks.org/mike/ d3 maker
2. ВЕб Технологии, алгоритмы, Hadoop, MapReduce etc. http://habrahabr.ru/company/mailru/blog/258045/

1. Introduction into HTTP - http://www.httpwatch.com/httpgallery/introduction/
2. WebGl: - http://www.learnopengles.com/understanding-opengls-matrices/ , http://learningwebgl.com/blog/?p=11
3. Memory - http://www.akkadia.org/drepper/cpumemory.pdf
4. Internet Protocol Suite - namen und Wozu sie gut sind lernen! http://en.wikipedia.org/wiki/Internet_Protocol_Suite

1. online tool to solve AON Switch-tests :) Also the AON tests with double filters https://www.jobtestprep.com/switch-challenge or https://prepopedia.com/procter-and-gamble-switch-challenge/
2. Collections questions http://javarevisited.blogspot.de/2011/11/collection-interview-questions-answers.html http://docs.oracle.com/javase/tutorial/collections/
3. Reactive Extensions, Monaden und JS und Java? http://www.heise.de/developer/artikel/Reactive-Programming-vom-Hype-zum-Praxiseinsatz-2059533.html?artikelseite=3
4. Concurrency Utils http://tutorials.jenkov.com/java-util-concurrent/index.html
5. Development and Test on Amazon Web Services
6. https://d0.awsstatic.com/whitepapers/aws-development-test-environments.pdf

1. Flutter - Google framework for native cross platform apps
2. Интерфейсный дайджест http://habrahabr.ru/company/mailru/blog/183950/
3. Spring MVC + Angular - http://blog.angular-university.io/developing-a-modern-java-8-web-app-with-spring-mvc-and-angularjs/
4. Google Frontend Developer - https://br.udacity.com/
5. Front End Frameworks by Google https://www.udacity.com/course/front-end-frameworks--ud894
6. Martin Fowler's Patterns http://martinfowler.com/eaaDev/index.html
7. Martin Fowler's GUI Architectures - http://martinfowler.com/eaaDev/index.html

1. Design Thinking http://www.sapdesignguild.org/community/design/design_thinking.asp
2. Alternative Datenströme in NTFS http://de.wikipedia.org/wiki/Alternativer_Datenstrom und “Zone Identifier”

1. Design Thinking - http://www.sapdesignguild.org/community/design/design_thinking.asp
2. OKRs – Object Key Results

Ja, Flutter kann sehr gut genutzt werden, um deutsche Accessibility-Anforderungen einzuhalten. Flutter bietet eine solide Grundlage für die Entwicklung barrierefreier Apps und erfüllt viele der in Deutschland geltenden Standards. Hier sind einige Gründe dafür:

* Umfassende Unterstützung für Accessibility-Features: Flutter stellt eine Vielzahl von Widgets und Werkzeugen zur Verfügung, die speziell für die Entwicklung barrierefreier Apps konzipiert sind. Dazu gehören:

• Semantische Widgets: Widgets wie Semantics, AccessibleNavigation, und MergeSemantics ermöglichen es, die Bedeutung von UI-Elementen für Screenreader zu definieren und die Navigation zu verbessern.

• Unterstützung für verschiedene Eingabemethoden: Flutter unterstützt verschiedene Eingabemethoden wie Tastatur, Touch, Maus und Gamecontroller.

* Gute Dokumentation und Community: Flutter verfügt über eine umfangreiche Dokumentation und eine aktive Community, die bei der Umsetzung von Accessibility-Anforderungen unterstützt. Wichtige Punkte bei der Entwicklung barrierefreier Flutter-Apps:

* Einhaltung der WCAG: Die Web Content Accessibility Guidelines (WCAG) sind ein international anerkannter Standard für Barrierefreiheit. Flutter-Apps sollten die relevanten WCAG-Kriterien erfüllen.

* Regelmäßige Tests: Es ist wichtig, Flutter-Apps regelmäßig auf Barrierefreiheit zu testen, um sicherzustellen, dass sie für alle Benutzer zugänglich sind.

* Nutzung von Accessibility-Tools: Es gibt verschiedene Tools und Plugins, die bei der Überprüfung der Barrierefreiheit von Flutter-Apps helfen können. Zusätzliche Aspekte:

* Deutsche rechtliche Anforderungen: Informiere dich über die spezifischen gesetzlichen Anforderungen in Deutschland, insbesondere die Barrierefreie-Informationstechnik-Verordnung (BITV).

* Continuous Integration: Integriere Accessibility-Tests in deinen CI/CD-Prozess, um sicherzustellen, dass Barrierefreiheit ein fester Bestandteil deines Entwicklungsprozesses ist.

Checkliste

https://userway.org/de/konformitaet/bitv/