{"title":"JVM Bloggers","description":"JVM Bloggers aggregated feed. You can customize your rss results by using parameters `limit` and 'excludedAuthors` (comma delimited names) parameters. Example: http://jvm-bloggers.com/pl/rss?limit=5&excludedAuthors=Tomasz Dziurko Adam Warski","entries":[{"link":"https://jvm-bloggers.com/r/qy82aay","title":"Java 22 i najlepsza zmiana: współbieżne zbieracze w strumieniach","author":"Piotr Przybył","description":"
Java 22 zostanie wydana jutro. W tej wersji jest wiele super rzeczy. Podejrzewam, że korzystanie z wywołań rodzimych/zewnętrznych w projekcie Panama sprawi, że życie wielu osób stanie się łatwiejsze, jak również trwające zmiany we współbieżności, szablonach napisów i wreszcie możliwość wywołania czegoś przed Java 8 była dużym kamieniem milowym w rewolucji Javy w swoim czasie. Pamiętam atmosferę po stosunkowo niewielkim wydaniu Javy 7, wersja 8 była NAPRAWDĘ WIELKA. Wprowadzenie lambd pozwoliło Stream API na istnienie w Javie 8 (bez krwawiących oczu, oczywiście). Moim zdaniem skierowało to Javę w stronę deklaratywnego i funkcyjnego sposobu myślenia o przetwarzaniu danych: zamiast pętli z pośrednimi wywołaniami i pakowania wyników w pojedynczy obiekt, mogliśmy wreszcie wyrazić intencję w bardziej deklaratywny sposób.<\/p>\n API strumieni miało moim zdaniem co najmniej dwie większe wady w momencie wprowadzenia, skutecznie uniemożliwiając jego użycie w wielu krytycznych scenariuszach przetwarzania danych.<\/p>\n W bardzo uproszczony sposób cykl życia strumienia można było streścić w ten sposób:<\/p>\n Zacznijmy od końca: kolektory (ang. collectors<\/em>). Jeśli nie byliśmy zadowoleni z prostego Jeśli to ciągle nie wystarczało, mogliśmy napisać swój własny kolektor. I to pierwsze ograniczenie: to było, o ile mi wiadomo, jedyne miejsce rozszerzeń w StreamAPI. Jeśli potrzebowaliśmy czegoś specjalnego, musieliśmy albo wprowadzić dziwne struktury danych pośrednich do obsługi tego w operacjach pośrednich (szukaj “ciekawych” przykładów w JEP 461<\/a>), albo de facto odkładać to do fazy zbierania. Co było dość dziwne, ponieważ niweczyło to cały cel wyrażania kroków przetwarzania danych za pomocą operacji pośrednich przed krokiem kolekcji. Lub mogliśmy to zrobić w pętli, w dobrym, starym stylu imperatywnym.<\/p>\n Masz więc 8 rdzeni w swoim komputerze. I, powiedzmy, 64 elementy w swoim strumieniu. Zatem dochodzisz do wniosku, że ustawienie strumienia jako A potem wszyscy odkryliśmy, że (prawie) wszystkie wątki w strumieniach równoległych pochodzą z tej samego puli. A co gorsza, że są blokowane przez IO. (A tutaj pomijamy całą historię stosu reaktywnego i świętych wojen między reakcjonistami a wyznawcami wątków wirtualnych. Dziś nie mam nastroju na świętą wojnę, przepraszam.)<\/p>\n Z tych i innych powodów w przeszłości zwykliśmy przełączać się na stos reaktywny, aby mieć nieblokujące przetwar...","date":"18/03/2024 15:00"},{"link":"https://jvm-bloggers.com/r/3hMejf4","title":"Przepisujemy moduł w systemie. Odc. 5. Twórz język, nie słownik","author":"Michał Bartyzel","description":" This is post 5 of 5 in the series “Przepisujemy moduł w systemie” Przepisujemy moduł w systemie odc. 1 Przepisujemy moduł w systemie odc. 2 Przepisujemy moduł w systemie odc. 3 Przepisujemy moduł w systemie. Odc. 4.: porządkowanie Przepisujemy moduł w systemie. Odc. 5. Twórz język, nie słownik Przypominam, że prowadzisz warsztat Event Storming i […]<\/p>\n Artykuł Przepisujemy moduł w systemie. Odc. 5. Twórz język, nie słownik<\/a> pochodzi z serwisu IT spotyka klienta<\/a>.<\/p>\n","date":"17/03/2024 07:00"},{"link":"https://jvm-bloggers.com/r/FlXAh9h","title":"Java Development with Odo on Podman, Kubernetes and OpenShift","author":"Piotr Mińkowski","description":" In this article, you will learn how to develop and deploy Java apps on Podman, Kubernetes, and OpenShift with odo. Odo is a fast and iterative CLI tool for developers who want to write, build, and deploy applications on Kubernetes-native environments. Thanks to odo you can focus on the most important aspect of programming – […]<\/p>\n The post Java Development with Odo on Podman, Kubernetes and OpenShift<\/a> appeared first on Piotr's TechBlog<\/a>.<\/p>\n","date":"15/03/2024 11:11"},{"link":"https://jvm-bloggers.com/r/06aDyn4","title":"Link Dump #130","author":"Sebastian Malaca","date":"15/03/2024 10:00"},{"link":"https://jvm-bloggers.com/r/SIgrSdJ","title":"216. W kierunku blokujących strumieni - Adam Warski","author":"Wrocław JUG","date":"14/03/2024 18:00"},{"link":"https://jvm-bloggers.com/r/ScV5yZg","title":"216. Mikrousługi w praktyce: sukcesy i porażki - Rafał Maciak","author":"Wrocław JUG","date":"14/03/2024 18:00"},{"link":"https://jvm-bloggers.com/r/IXZRmT9","title":"Implementing cloud VPN solution using AWS, Linux and WireGuard","author":"ScalaC","description":" What is a VPN, and why is it important? A Virtual Private Network, or VPN in short, is a tunnel which handles all the internet data sent and received between Point A (typically an end-user) and Point B (application, server, or another end-user). This is done with security and privacy in mind, because it effectively […]<\/p>\n The post Implementing cloud VPN solution using AWS, Linux and WireGuard<\/a> appeared first on Scalac - Software Development Company - Akka, Kafka, Spark, ZIO<\/a>.<\/p>\n","date":"14/03/2024 17:55"},{"link":"https://jvm-bloggers.com/r/klQ2zwI","title":"Monica McGuigan - My Scala Story","author":"SoftwareMill","description":"\n \n \n Scala experts share their Scala Stories to celebrate the 20th anniversary of Scala in 2024. Meet Monica McGuigan, and follow her on LinkedIn<\/a>.<\/p>\n I started properly learning Scala in 2022 when I joined my current team for my first developer job out of university. My experience in software before this was C#, C++, and some front-end technologies. So, switching to the world of functional programming was not<\/em> without its challenges.<\/p>\n Initially, I found the learning curve pretty steep; there was a huge amount to understand and a lot of confusing concepts to take on board pretty quickly. Slowly but surely, I started to get my head around writing Scala code, and haven’t looked back since!<\/p>\n I would say the main influence on how I problem-solve would have to be Scalas’ type system. Being able to rely on it so consistently, in my experience, has been great. For example, when you’re pattern matching, you know with its exhaustivity that you are covering all bases. This is in stark contrast to my front-end experience in JavaScript, where you just had to hope what you were writing was correct, and you’d find out at runtime whether or not that's true. Having compile-time confidence in your code is far more enjoyable.<\/p>\n Learning Scala has been my first interaction with FP, so I can definitely see where the influence of this paradigm on how I write code comes from. It feels very natural to decompose problems into discrete functions you chain together, with an emphasis on what the input and output types are. <\/p>\n I also like how Scala isn’t strictly a pure functional language, and when you need to use imperative techniques, it’s flexible enough to allow you to, e.g., using local mutability when it makes the most sense to do so. <\/p>\n <\/p>\n I mean, this really says it all...<\/p>\n For development, I use IntelliJ with SBT. <\/p>\n Something so simple yet so helpful that I’ve come to rely on are the context actions. The two I use the most are the type hints<\/em> and the collection inspections<\/em>.<\/p>\n Specifically, when I’m working with chaining lots of functions together, getting type hints helps to keep me sane and focused on the problem. Then, I find it incredibly helpful getting suggestions for writing more readable and idiomatic code from the collection inspections, especially as I’m refactoring code that is a little messy from the process of being written. <\/p>\n And then for libraries, my team mostly uses the Typelevel ecosystem: including Cats, Cats-Effect and Http4s.<\/p>\n The impact of the Scala community on my learning journey so far cannot be overstated. From the very first few...<\/p>\n \n ","date":"14/03/2024 17:30"},{"link":"https://jvm-bloggers.com/r/tZRcCom","title":"White House recommends using memory-secure languages, including Java - JVM Weekly vol. 75","author":"Vived","description":"Today we have security themes native to the US, a continuation (and probably already a summary) of the 1BRC theme and an interesting case from Netflix.","date":"14/03/2024 15:01"},{"link":"https://jvm-bloggers.com/r/0TTRQem","title":"GeeCON Prague 2023: Bogomil Shopov - Where Did All the Fun Go?","author":"GeeCON","date":"14/03/2024 11:52"},{"link":"https://jvm-bloggers.com/r/ZfTSRK9","title":"GeeCON Prague 2023: Tannaz N. Roshandel - Machine Intelligence With Humans in Mind","author":"GeeCON","date":"14/03/2024 11:52"},{"link":"https://jvm-bloggers.com/r/NdG4zjV","title":"GeeCON Prague 2023: Markus Kett - High Performance Java Cloud Native Apps","author":"GeeCON","date":"14/03/2024 11:51"},{"link":"https://jvm-bloggers.com/r/Q1RAaV3","title":"Przyjdź na SpHERe.it Conference stacjonarnie lub online","author":"BulldogJob","description":" Zapisz się na konferencję organizowaną przez Sphere.it, która odbędzie się stacjonarnie oraz w sieci już 15 marca 2024.<\/p> Czytaj dalej<\/a><\/p>","date":"13/03/2024 14:50"},{"link":"https://jvm-bloggers.com/r/m06d48p","title":"Jak zadbać o komfort i produktywność w pracy programisty? Wybierz odpowiedni ekosystem sprzętów","author":"JustJoinIT","description":" Przez ostatnie kilka tygodni miałam przyjemność testować produkty z serii MX od Logitech (zestaw mysz, klawiatura oraz najnowszy model kamery). Czy poleciłabym je programistom? Zdecydowanie tak. Zobaczcie dlaczego. Mysz, klawiatura i dobrej jakości kamera — to elementy biurka (prawie) każdego programisty. Istotne są zwłaszcza te dwa pierwsze, dlatego ważne jest, by były maksymalnie ergonomiczne, funkcjonalne […]<\/p>\n Artykuł Jak zadbać o komfort i produktywność w pracy programisty? Wybierz odpowiedni ekosystem sprzętów<\/a> pochodzi z serwisu Just Geek IT<\/a>.<\/p>\n","date":"13/03/2024 11:26"},{"link":"https://jvm-bloggers.com/r/30pR1LS","title":"215. Wojownicy, bardowie, druidzi i czarodzieje w IT - jak z nimi rozmawiać? - Paweł Zajączkowski","author":"Wrocław JUG","date":"12/03/2024 18:00"},{"link":"https://jvm-bloggers.com/r/mzHmobl","title":"Linux 6.8 - nowe funkcje i ulepszenia w jądrze","author":"BulldogJob","description":" Sprawdź, co nowego w najświeższej wersji Linuxa 6.8. <\/p> Czytaj dalej<\/a><\/p>","date":"12/03/2024 16:30"},{"link":"https://jvm-bloggers.com/r/lsLc6ld","title":"Handling errors in direct-style Scala","author":"SoftwareMill","description":"\n \n \n Error handling is the cornerstone of any library that orchestrates the execution of user-provided code. That's also the case in ox<\/a>, a library for safe direct-style concurrency and resiliency for Scala on the JVM.<\/p>\n <\/p>\n Many of ox's features are centered around error handling: structured concurrency<\/a>, retries<\/a>, error propagation in channels<\/a>. However, so far the primary error signaling mechanism in ox were exceptions. In Scala, all exceptions are unchecked. That's due to the many reasons<\/a> why Java's checked exceptions are considered a failed feature of the language.<\/p>\n However, while having only unchecked exceptions alleviates some of the problems of their checked flavor, it also makes a dent in the otherwise type-safe nature of Scala codebases.<\/p>\n Let's first explore different ways in which we might represent errors and then examine, how such representations are supported in ox.<\/p>\n To rectify the dent in type-safety that we mentioned, it's often recommended to represent errors differently: as values. When using such a representation, the type of the error is part of each method's signature, allowing for more precision, compile-time safety, and better documentation. A primary example of such an approach is ZIO<\/a>, where each computation description is parameterized by the type of error it might encounter. However, ZIO uses monadic composition to define programs and requires an entirely different programming style—something the direct style approach tries to avoid.<\/p>\n Still, we can represent errors as values when using direct style. It's worth noting that exceptions are still possible when an error is represented as a value. Hence, we need to make a distinction as to which errors should use which mechanism. I think the approach ZIO took: exceptions are used to signal \"defects\" in code (bugs<\/strong>), is quite sensible. On the other hand, any of the \"expected\" errors should be represented by values.<\/p>\n Of course, this is not a universal recipe, and it's quite possible that you'll need to adjust these definitions for your use case. However, it's worth specifying upfront what kind of error-handling mechanisms should be used and when. To distinguish bugs from the \"expected\" errors, represented as values, we'll use the term application errors<\/strong> going forward.<\/p>\n Most I/O libraries, especially Java ones, use exceptions to signal all kinds of errors—both the \"expected\" ones and bugs. Thus, it might be necessary to create utilities or use library wrappers that convert such exceptions to an as-a-value representation. Moreover, an unexpected error at one level might be an expected error at another, so we'll also need utilities to convert between the two representations.<\/p>\n<\/blockquote>\n Now that we have the basic terminology set up, we need some specific mechanisms to represent errors as values. One approach is to make the error states members of the data types<\/a> returned by your \"business\" functions. After all, since we are dealing with \"expected errors\", the business logic should handle the error states and the successful states. This might become hard when cross-cutting concerns are at play since we...<\/p>\n \n ","date":"12/03/2024 14:49"},{"link":"https://jvm-bloggers.com/r/SEZpfz5","title":"Niektórzy myślą, że Scrum Master jest „od gier i zabaw”. To mit","author":"JustJoinIT","description":" Z czego wynika krytyka Scrum Masterów? Zdaniem Dawida Chudka, który od 1.5 roku pracuje w tym zawodzie, między innymi z rozczarowania organizacji, które oczekiwały, że Scrum będzie odpowiedzią na wszystkie ich problemy. – Jednakże Scrum nie jest i nigdy nie będzie uniwersalnym rozwiązaniem – uważa Dawid. Rozmawiamy z nim m.in. o tym, jakie są najważniejsze […]<\/p>\n Artykuł Niektórzy myślą, że Scrum Master jest „od gier i zabaw”. To mit<\/a> pochodzi z serwisu Just Geek IT<\/a>.<\/p>\n","date":"12/03/2024 09:23"},{"link":"https://jvm-bloggers.com/r/FpDJNd7","title":"Big Picture Event Storming - finding the gaps","author":"SoftwareMill","description":"\n \n \n In my latest article<\/a> of the series about our Domain-Driven Design show-case project, which you can read more about here<\/a>, I covered our kickoff session of Big Picture Event Storming. Quick recap: we started with a chaotic exploration, which was a brain dump of relevant domain events from everyone involved. After that, we got down to organizing chaos by sorting out the events, removing duplicates, and fine-tuning them.<\/p>\n We wrapped the session with the events ordered in chronological order. We also pointed out a hot spot that highlighted the things we were not sure about. Additionally, we used some yellow sticky notes for the crucial bits we didn’t want to forget.<\/p>\n As a bonus, we pinpointed the initial sub-processes happening within the main devices inventory process. Those were highlighted, and we gave them temporary names. Here’s a snapshot of what our Miro board looked like when we were done:<\/p>\n <\/a><\/p>\n That looks pretty clear. But even with everything in order and the board looking sharp, we were aware that there could still be some gaps or inconsistencies hidden in our earlier modeling. Fortunately, Big Picture Event Storming helps identify such gaps or inconsistencies by providing two techniques - explicit walk-through<\/em> and reverse narrative<\/em>. Awareness of things we don’t know is often valuable knowledge for the stakeholders, especially when they didn’t know about it before.<\/p>\n In this post, I will dive into how we tackled the second part of our workshop. I'll share the techniques we used to ensure we had a complete picture of the process. But first, let’s start with some theory on the approaches to finding the gaps in the event flow.<\/p>\n The explicit walk-through technique is one approach of the Event Storming workshop that checks if the model is both accurate and complete. It involves a detailed review of the entire event sequence laid out during the workshop. It lets everyone involved check each part of the process together. This way, we can spot inconsistencies, unnecessary parts, or anything missing. It makes sure we all understand the business process.<\/p>\n During this, the facilitator might ask someone to start telling the story based on the events, following their order in time. This role of storyteller can be passed around to keep everyone engaged.<\/p>\n To effectively validate the process steps and identify potential gaps or inconsistencies, it’s crucial to ask the right questions while going through the events. Though the facilitator usually starts this, participants often see its value and start asking questions, too. The common, useful questions which help to find potential missing elements are:<\/p>\n Poznaj nowy język programowania Gleam, ideę jego stworzenia i sprawdź, czym się wyróżnia oraz jakie są jego słabe strony.<\/p> Czytaj dalej<\/a><\/p>","date":"11/03/2024 12:12"},{"link":"https://jvm-bloggers.com/r/O7653IA","title":"Od programisty do przedsiębiorcy. Wywiad z Kacprem Kaczmarkiem","author":"JustJoinIT","description":" Kacper Kaczmarek dość szybko doszedł do etapu seniora, a to dzięki jego zaangażowaniu w rozwój i ciągłe podnoszenie kompetencji. Od zawsze jednak chciał pracować nad swoimi produktami, dlatego zdecydował się na stopniowe zmniejszanie liczby godzin u pracodawcy. W ten sposób zadbał o stabilność finansową, a gdy poczuł, że biznes idzie dobrze, porzucił pracę programisty. Które z doświadczeń z […]<\/p>\n Artykuł Od programisty do przedsiębiorcy. Wywiad z Kacprem Kaczmarkiem<\/a> pochodzi z serwisu Just Geek IT<\/a>.<\/p>\n","date":"11/03/2024 09:40"},{"link":"https://jvm-bloggers.com/r/gzUBEpS","title":"Jak podnieść jakości życia zawodowego poprzez zmianę codziennych nawyków?","author":"Sii","description":" <\/p> Często zastanawiamy się, w jaki sposób ludzie zajmujący wysokie stanowiska doszli do miejsca, w którym się znajdują. Co miało wpływ … Continued<\/a><\/p>\n The post Jak podnieść jakości życia zawodowego poprzez zmianę codziennych nawyków?<\/a> first appeared on blogersii<\/a>.<\/p>","date":"11/03/2024 05:00"},{"link":"https://jvm-bloggers.com/r/OPSCKPo","title":"Transforming Legacy Projects to Microservices: Expert Guidance for Success","author":"Iterators","description":" Picture this: You’re navigating the vast landscape of software development, and you find yourself face-to-face with the challenge of legacy projects. It’s a familiar story for many businesses…<\/p>\nThe post How Microservices Can Help You Upgrade and Maintain Legacy Projects<\/a> first appeared on Iterators<\/a>.","date":"08/03/2024 17:47"},{"link":"https://jvm-bloggers.com/r/DaS7dn7","title":"Zainab Ali - My Scala Story","author":"SoftwareMill","description":"\n \n \n Another wonderful guest in our My Scala Story series is Zainab Ali<\/a>. She is a functional programmer, educator, open source contributor and organizer of the London Scala User Group. She is a maintainer of fs2 and the original author of its reactive streams component. For the past five years, she’s helped developers master the art of functional programming in Scala. <\/p>\n Believe it or not, I used to be an object-oriented Java developer. I took a break from my first job to write a game engine and picked Scala for a new start.<\/p>\n Initially, I thought it was pretty daunting. I'd been coding in Java, and only Java, up to that point, and good Java code always looked the same. Scala brought so many different ways of expressing things, not just in its syntax but in its programming paradigms. My code was difficult to understand, but I could suddenly solve many more problems than otherwise.<\/p>\n It opened my eyes to new ways of thinking and understanding code. Looking back on it, the biggest challenge was not so much Scala as leaving my comfort zone and learning a second programming language. Since then, I've happily dived into more languages than I can count and am much better at it.<\/p>\n I first encountered fs2 while writing game engines and hunting for a functional mechanism to represent animations. I had already been dazzled by type-level programming with shapeless and functional programming with cats, but it was fs2 that got me hooked. It surpassed anything I had ever encountered for expressing iterative computations, both in Scala and beyond. It still holds its ground as the most powerful stream processing library and one I'm proud to be a maintainer of now<\/p>\n Over the years, I've dipped my toes into many languages. But the thing that keeps drawing me back to Scala is its flourishing ecosystem and innovative community.<\/p>\n It’s a bit cynical, but I always love to share this XKCD comic: <\/p>\n <\/p>\n The Scala community was my first experience of open source.<\/p>\n It was a slow awakening. At first, I realized that the libraries I used were free for me to explore, that I could raise issues and discuss them; and then that I could contribute back and fix things myself, and thus improve the ecosystem for everyone else.<\/p>\n I was always a bit shy on online forums, but I went in person to one of the Typelevel Hack the Tower days. I spent the entire day with a small group of Scala open source contributors, discussing cats and the delights and challenges of functional programming. I learned so much through those conversations, sharing problems,...<\/p>\n \n ","date":"08/03/2024 12:33"},{"link":"https://jvm-bloggers.com/r/HchPFMf","title":"Determinanty Poka-Yoke jako metody zapobiegania defektom w informatyce","author":"Sii","description":" <\/p> Poka-Yoke, wywodzący się z japońskich praktyk zarządzania, stanowi skuteczne rozwiązanie w zapobieganiu błędom poprzez eliminację najczęstszych źródeł i rozpoznawanie podstawowych … Continued<\/a><\/p>\n The post Determinanty Poka-Yoke jako metody zapobiegania defektom w informatyce<\/a> first appeared on blogersii<\/a>.<\/p>","date":"08/03/2024 05:00"},{"link":"https://jvm-bloggers.com/r/0btsqrg","title":"Wednesday Links - Edition 2024-03-06","author":"ViacomCBS","description":"Random Newsletter (8 min)🔢 https://www.javaspecialists.eu/archive/Issue315-Random-Newsletter.html","date":"06/03/2024 01:00"},{"link":"https://jvm-bloggers.com/r/9mEsjMl","title":"Password Manager Menadżer haseł","author":"Tomasz Woliński","description":" Witaj w erze cyfrowej, gdzie hasło to nie tylko sposób na zabezpieczenie Twojej skrzynki pocztowej, ale brama do całego uniwersum danych osobowych. W dzisiejszym świecie każdy serwis, każda aplikacja prosi nas o kolejne hasło. Jak więc nie zgubić się w tym labiryncie cyfrowych zamków? Sekretem jest menadżer haseł (ang. Password Manager), narzędzie, które nie tylko ułatwi życie, ale i znacząco podniesie Twoje bezpieczeństwo w sieci. Password Manager – wprowadzenie Z tego materiału dowiesz się: Czym jest menadżer haseł? Dlaczego menadżer haseł jest istotny? Jakie…<\/p>\n Artykuł Password Manager ⭐⭐⭐⭐⭐⭐ Menadżer haseł<\/a> pochodzi z serwisu StormIT.pl 👽 👾 🤖<\/a>.<\/p>\n","date":"14/03/2024 13:07"},{"link":"https://jvm-bloggers.com/r/6jEFcSS","title":"Płatna wyszukiwarka? Czy świat stanął na głowie? Kagi vs Google","author":"Maciej Waksmański","description":" Dawno, dawno temu… czy ktoś z was pamięta jeszcze co było przed wyszukiwarką Google? Czy w ogole sobie może wyobrazić, że Google to nie pierwsza wyszukiwarka i że przed nią były między innymi Yahoo czy AltaVista? Aktualnie, oprócz Google są jeszcze Bing czy DuckDuckGo i wszystkie te wyszukiwarki łączy jedna rzecz: są „darmowe”. Kagi.com chce […]<\/p>\n Artykuł Płatna wyszukiwarka? Czy świat stanął na głowie? Kagi vs Google<\/a> pochodzi z serwisu DevReview.pl<\/a>.<\/p>\n","date":"14/03/2024 11:59"},{"link":"https://jvm-bloggers.com/r/WNjDdDD","title":"Jekyll i Buddy, czyli mój sposób na publikowanie treści na bloga","author":"Cezary Sanecki","description":"\n \n Kiedyś wspomniałem o tym, że przeszedłem z platformy Wordpress na Jekyll. I do dziś uważam, że to był dobry wybór! Głównie z tego powodu, że teraz wszystko mogę robić z pozycji edytora tekstu. Przy pomocy Markdown piszę tekst, potem robię commita i tyle! Nie musze odpalać żadnej przeglądarki jak to...\n ","date":"14/03/2024 00:00"},{"link":"https://jvm-bloggers.com/r/OLBywiY","title":"Tworzenie projektu w oparciu o legendarne library-by-example","author":"Cezary Sanecki","description":"\n \n Jest to kolejny wpis z serii dotykowanej konkursowi 100commitów. Na ten moment muszę przyznać, że cel dotyczący refaktoryzacji, jaki chciałem osiągnąć, oddalił się. Wychodzę z założenia, że techniki refaktoryzacyjne jednak lepiej się ćwiczy na cudzych projektach. Wtedy musimy odnaleźć wymagania biznesowe zaszyte w kodzie. Natomiast jak piszemy coś własnego i...\n ","date":"13/03/2024 00:00"},{"link":"https://jvm-bloggers.com/r/ggYZohJ","title":"Sytuacja na rynku IT: Perspektywa Java Developera","author":"SoftwareSkill","description":" W obliczu zmian gospodarczych i technologicznych, rynek IT oferuje wyzwania i możliwości dla Java Developerów, podkreślając znaczenie ciągłego rozwijania umiejętności technicznych i miękkich. Sztuczna inteligencja i adaptacyjność stają się kluczowe w kontekście dynamicznie zmieniających się wymagań rynkowych. Przyszłość w IT zależeć będzie od gotowości do nauki i innowacji, co umożliwi Java Developerom utrzymanie konkurencyjności.<\/p>\n Artykuł Sytuacja na rynku IT: Perspektywa Java Developera<\/a> pochodzi z serwisu SoftwareSkill.pl<\/a>.<\/p>\n","date":"12/03/2024 21:33"},{"link":"https://jvm-bloggers.com/r/uAmnbAH","title":"HandsOnArchitects celebrates its first anniversary","author":"Hands-on Software Architects","description":"As HandsOnArchitects marks its first anniversary, we're excited to revisit our top-performing blog posts that have resonated with our…","date":"12/03/2024 01:00"},{"link":"https://jvm-bloggers.com/r/uPdqeeL","title":"Kafka Offset with Spring Boot","author":"Piotr Mińkowski","description":" In this article, you will learn how to manage Kafka consumer offset with Spring Boot and Spring Kafka. An inspiration for preparing this article was the feedback I received after publishing the post describing concurrency with Kafka and Spring Boot. You were asking me questions related not only to concurrency but also to the consumer […]<\/p>\n The post Kafka Offset with Spring Boot<\/a> appeared first on Piotr's TechBlog<\/a>.<\/p>\n","date":"11/03/2024 14:09"},{"link":"https://jvm-bloggers.com/r/hXnoyfM","title":"Przepisujemy moduł w systemie. Odc. 4: porządkowanie","author":"Michał Bartyzel","description":" This is post 4 of 5 in the series “Przepisujemy moduł w systemie” Przepisujemy moduł w systemie odc. 1 Przepisujemy moduł w systemie odc. 2 Przepisujemy moduł w systemie odc. 3 Przepisujemy moduł w systemie. Odc. 4.: porządkowanie Przepisujemy moduł w systemie. Odc. 5. Twórz język, nie słownik Ostatni artykuł z tej serii zostawił Cię […]<\/p>\n Artykuł Przepisujemy moduł w systemie. Odc. 4.: porządkowanie<\/a> pochodzi z serwisu IT spotyka klienta<\/a>.<\/p>\n","date":"11/03/2024 13:01"},{"link":"https://jvm-bloggers.com/r/IvG5jPJ","title":"Testy integracyjne w Spock dla Spring Boot 3","author":"Cezary Sanecki","description":"\n \n Jeśli planujesz korzystać ze Spock, aby pisać testy integracyjne w Spring Boot 3 (w moim przypadku 3.2.2) to mam dla Ciebie ostrzeżenie. Jeśli w swoim narzędziu budowania będziesz miał wpis: 1 2 3 4 5 6 <dependency> <groupId>org.spockframework</groupId> <artifactId>spock-spring</artifactId> <version>2.3-groovy-4.0</version> <scope>test</scope> </dependency> To niestety twój test, podobny do tego niżej,...\n ","date":"09/03/2024 00:00"},{"link":"https://jvm-bloggers.com/r/bpbF8cY","title":"Link Dump #129","author":"Sebastian Malaca","date":"08/03/2024 10:00"},{"link":"https://jvm-bloggers.com/r/xMQbeiq","title":"Building application with AI: from concept to prototype.","author":"ScalaC","description":" Introduction – Artificial Intelligence in Application Development When a few years ago the technological world was taken over by the blockchain trend, I must admit that I didn’t hop on that train. I couldn’t see the real value that this technology could bring to someone designing application interfaces. However, when the general public got to […]<\/p>\n The post Building application with AI: from concept to prototype.<\/a> appeared first on Scalac - Software Development Company - Akka, Kafka, Spark, ZIO<\/a>.<\/p>\n","date":"07/03/2024 16:59"},{"link":"https://jvm-bloggers.com/r/FTuaHwS","title":"Code Reflection ️ Triton: Further improvements to GPU programming in Java - JVM Weekly vol. 74","author":"Vived","description":"Today we return to text form, with new JEPs, Code Reflection and a mega interesting Release Radar.","date":"07/03/2024 15:01"},{"link":"https://jvm-bloggers.com/r/NHGXQRU","title":"JDK 22 in a nutshell","author":"SoftwareMill","description":"\n \n \n With the regular cadence of Java releases, developers eagerly anticipate each new version for the enhancements and features it brings. As the next iteration, Java 22, prepares for release on 19th March, it's time to dive into the improvements and updates that await. From performance enhancements to streamlined APIs, let's explore what Java 22 has in store for developers.<\/p>\n This section focuses on the features that are now fully integrated into Java 22, enhancing the platform without requiring any special activation.<\/p>\n Is an enhancement to the G1 garbage collector, primarily aiming to allow garbage collection during active JNI regions. It addresses the issue of G1's inability to pin arbitrary regions during minor collections, a capability already present in major collections. By implementing this feature, G1 can effectively manage JNI critical regions without disabling GC, pinning regions containing critical objects while allowing garbage collection in unpinned areas. This enhancement will effectively prevent thread stalling and eliminate potential latency related to it.<\/p>\n Improvement introduces an API for Java to efficiently interact with foreign functions and memory, i.e., code and data outside the Java Virtual Machine (JVM). This API aims to replace the existing Java Native Interface (JNI) with a more concise and safer approach. Key features include the ability to invoke foreign functions and access foreign memory with performance comparable to JNI or better, broad platform support, and a focus on safety to prevent common bugs like use-after-free errors.<\/p>\n Enhancement Java with unnamed variables and patterns, indicated by the underscore This represents a further development from \"JEP 330: Launch Single-File Source-Code Programs<\/a>,\" which eliminated the explicit compilation step for single-file programs. This advancement facilitated a more fluid development process, particularly valuable during the prototyping phase. Now, this capability has been expanded to multi-file Java source code programs, further easing the transition from small-scale to larger, more complex programs.<\/p>\n In this update, we revisit features from earlier Java versions now in their second preview phase, aimed at gathering further feedback. Preview features in Java are not activated by default. To enable these features, you must explicitly include the There were no updates in these enhancements, as their specifications say:<\/p>\n We here propose to re-preview the API in JDK 22, without change, in order to gain additional experience and feedback.<\/em><\/p>\n<\/blockquote>\n For more information about these improvements, you can check our blog article<\/a>.<\/p>\n <\/p> W dzisiejszym świecie technologii, w którym innowacje i zmiany są na porządku dziennym, elastyczność umysłu oraz ciągły rozwój mają kluczowy … Continued<\/a><\/p>\n The post Nastawienie na rozwój – sekret efektywności zwinnych zespołów IT<\/a> first appeared on blogersii<\/a>.<\/p>","date":"07/03/2024 05:00"},{"link":"https://jvm-bloggers.com/r/ISfUBxS","title":"Thriving Remotely: My Journey with SoftwareMill","author":"SoftwareMill","description":"\n \n \n I had never been fully convinced about remote work. It just didn't feel right. It was hard to imagine how to become truly involved and immersed in the company's day-to-day operations. I wanted my contributions to be relevant and meaningful, not just to check tasks off a list. <\/p>\n As a software architect, I wanted to stay close to the business to unleash my potential. I needed a feeling of belonging somewhere, of being part of something much bigger than myself. A remote position seemed rather hollow and hard to find satisfying to me.<\/p>\n Today, I want to share my thoughts and insights on how I feel and what I learned during the last 18 months of working fully remotely. I am sharing this because it exemplifies how remote cooperation should look, and I hope to inspire some readers to adopt some solutions and, more importantly, the mindset.<\/p>\n <\/p>\n I fell in love with functional programming, and while searching more and more about it, I ended up on SoftwareMill's blog increasingly often. The company was apparent and visible in the Scala ecosystem, which I was interested in back then. However, despite its strong Scala reputation, Scala is one of many technologies the company uses to build its solutions.<\/p>\n So, the desire to become part of it began by becoming aware of what they are doing, how they approach it, and who works there. I learned much about the company's mindset and approach to solving challenging problems. SoftwareMill contributes to projects that add something to the world, engaging in challenging and complex fields like the health sector, fintech, or telecom. The company does not participate in anything harmful, like gambling, for example. Such distinction is important to me, so I took my chances and decided to join SoftwareMill.<\/p>\n SoftwareMill is entirely open and happy to chat. There was (and still is) a public Ask Me Anything<\/a> Slack channel where you can ask any question without bothering with any formal communication. I was convinced at that stage.<\/p>\n The recruitment process clearly shows the extensive effort SoftwareMill puts into hiring the right people. Initially, I was asked to fill out a short form with five simple questions. The next step was an informal, roughly 1-hour long conversation with Sylwia, a wonderful person responsible for HR, among other duties. The goal was to meet and chat to see if we could more or less get along. This was an enjoyable experience for me. Then, I was asked to implement a simple technical task in Scala, which was fun to do. I was expected to spend just a few hours demonstrating my thought process, design skills, and problem-solving approach. Shortly after, they responded with thorough code reviews and feedback. I was ready for a technical interview, which was the next step in the process. The technical interview lasted about 2 hours and included two other engineers. The atmosphere was relaxed, and I quickly felt comfortable there, which allowed me to grasp what working with them...<\/p>\n \n ","date":"06/03/2024 16:12"},{"link":"https://jvm-bloggers.com/r/WA2xX1Z","title":"Unlocking Kafka's Potential: Tackling Tail Latency with eBPF","author":"Allegro Tech","description":" At Allegro<\/a>, we use Kafka<\/a> as a backbone for asynchronous communication between microservices. With up to\n300k messages published and 1M messages consumed every second, it is a key part of our infrastructure. A few months ago, in our main Kafka cluster, we noticed\nthe following discrepancy: while median response times for produce requests<\/a>\nwere in single-digit milliseconds, the tail latency was much worse. Namely, the\np99 latency was up to 1 second, and the p999 latency was up to 3 seconds. This was unacceptable for a new project that we were about to start, so we\ndecided to look into this issue. In this blog post, we would like to describe our journey — how we used Kafka protocol sniffing and eBPF to identify and remove\nthe performance bottleneck.<\/p>\n\n <\/p>\n\n Kafka brokers expose various metrics<\/a>. From them, we were able to tell that\nproduce requests were slow for high percentiles, but we couldn’t identify the cause. System metrics were also not showing anything alarming.<\/p>\n\n To pinpoint the underlying problem, we decided to trace individual requests. By analyzing components of Kafka involved in handling produce requests,\nwe aimed to uncover the source of the latency spikes. One way of doing that would be to fork Kafka, implement instrumentation, and deploy our custom version\nto the cluster. However, this would be very time-consuming and invasive. We decided to try an alternative approach.<\/p>\n\n The first thing we did was finding arrival<\/em> and end<\/em> times for every Kafka produce request.<\/p>\n\nsuper<\/code>. Super! Jednak jest jedna rzecz, która podejrzewam stanie się moim (prawie) ukrytym bohaterem Javy 22. Ludziska, przedstawiam wam
Gatherers.mapConcurrent<\/code>!<\/p>\n
Strumienie są bohaterem Javy 8 (ale nie w świecie równoległym)<\/h3>\n
Rozszerzaj, ale tylko raz<\/h4>\n
\n
filter<\/code>,
map<\/code> lub
flatMap<\/code> (lub
peek<\/code>, ale to było tylko do debugowania, prawda? PRAWDA???)<\/li>\n
joining<\/code>,
reduce<\/code> czy podobnych, można było sięgnąć po jeszcze prostsze
toList<\/code> (od Javy 16, jeśli dobrze pamiętam), lub
teeing<\/code> (od Javy 12), jeśli trzeba było przekazać obiekty do dwóch lub więcej kolektorów. Lub jeśli istniały naprawdę wymyślne potrzeby, można było ujawnić wszystkie mroczne moce, które zdobyliśmy na “Wprowadzeniu do SQLa” i skomponować kolektory za pomocą
mapping<\/code>,
filtering<\/code>,
groupingBy<\/code>,
partitioningBy<\/code>,
collectingAndThen<\/code>, itp., itp.<\/p>\n
Gdzie są moje rdzenie?<\/h4>\n
.parallel()<\/code> może sprawić, że cała operacja na strumieniu będzie w niektórych przypadkach około 8 razy szybsza. Nawet zweryfikowałeś/aś to w
jshell<\/code>, i tak, 8 razy szybsza, więc szybko kopiuj-wklej w wielu miejscach, i możemy
git push --force<\/code> ;-)<\/p>\n
How did you first get introduced to Scala, and what did you think about it?<\/h2>\n
How has Scala influenced your approach to solving programming problems?<\/h2>\n
What is your favourite programming meme?<\/h2>\n
Image source<\/a><\/h4>\n
What are your go-to tools and libraries when working as a software developer?<\/h2>\n
How has the Scala community impacted your programming journey? Any standout interactions or support stories to share?<\/h2>\n
Errors as values<\/h2>\n
\n
Picking a representation<\/h2>\n
Picture 1. Miro board after the timeline enforcement phase, CLICK to preview on Miro<\/strong><\/a><\/h4>\n
Explicit walk-through<\/strong><\/h2>\n
\n
How did you first get introduced to Scala, and what did you think about it?<\/h2>\n
Tell us about a moment when you realized, \"Aha! Scala is awesome!\" What Scala's features and capabilities made you feel that way?<\/h2>\n
What is your favourite programming meme?<\/h2>\n
source<\/a><\/h4>\n
How has the Scala community impacted your programming journey? Any standout interactions or support stories to share?<\/h2>\n
Stable Features<\/h2>\n
JEP 423: Region Pinning for G1<\/a><\/h3>\n
JEP 454: Foreign Function & Memory API<\/a><\/h3>\n
JEP 456: Unnamed Variables & Patterns<\/a><\/h3>\n
_<\/code>, optimizes cases where unused variable declarations or nested patterns are involved. This streamlines the language, aligning it with common practices in other programming languages. This refinement boosts developer experience and code clarity, making Java more intuitive and concise in handling redundant naming.<\/p>\n
JEP 458 Launch Multi-File Source-Code Programs<\/a><\/h3>\n
Second Preview<\/h2>\n
--enable-preview<\/code> flag when running your Java application. <\/p>\n
JEP 464: Scoped Values<\/a> and JEP 462: Structured Concurrency <\/a><\/h3>\n
\n
Decision<\/h1>\n
Hiring<\/h1>\n
The Need for Tracing<\/h2>\n