Lim Afriyadi

REST Resources caching methods, 1. Expires Header (HTTP 1.0) 2. Cache-Control Header (HTTP 1.1) 3. ETags (Entity Tags) https://lnkd.in/gnw6vSJy

5

Did you know that you can optimize your nodejs servers further by adjusting the GC settings? I always thought that nodejs was smarter in terms of setting GC object age settings according to the system resources but I realized that you can optimize this further. I recently stumbled upon "--max-semi-space-size" and had some direct effects on our API metrics. This setting helps the GC in terms of when it should try to free space for the young space and the semi space, no idea why it controls both. Setting this as 64mb will set the young space to 192MB, default setting for a system with 512MB is 1MB. This makes especially a lot of sense for API that does a lot of JSON parsing and create a lot of JS objects so that the GC doesn't block the event loop too long. Below is the snapshot showing how our metrics looked like afterwards. GC duration decreased drastically, CPU time decreased along with it thanks to less GC cycles and our event loop lag because more stable with less spikes/drops. Do you know other cool nodejs settings? Let me know the other cool nodejs settings that you use for optimizing your instances in the comments!

25

Reloading Golang server on file/s change (Increase your productivity to the maximum 🚀🚀🚀) I started to learn golang,coming from NodeJs we use nodemon most of the time to reload the server during development,so I thought why should I go to the terminal to rerun the Go compiler to see the updates every time I made changes 🤔🤔🤔!!!. After researching I found a very nice solution,using the beloved nodemon 😃 Just pretty simple command nodemon —exec go run main.go —signal SIGTERM

4

2 Komentar

<𝐒𝐮𝐩𝐞𝐫𝐜𝐡𝐚𝐫𝐠𝐞 𝐘𝐨𝐮𝐫 𝐆𝐨𝐥𝐚𝐧𝐠 𝐒𝐤𝐢𝐥𝐥𝐬: 𝐌𝐮𝐬𝐭-𝐇𝐚𝐯𝐞 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐑𝐞𝐬𝐨𝐮𝐫𝐜𝐞𝐬!> I often receive messages from aspiring developers on LinkedIn asking how they can kickstart their journey in Golang Backend Development. I'm not here to sell courses but to share what worked for me—a love for learning through books! Here are some essential reads that helped me master Golang: 1️⃣ "Concurrency in Go" - Dive deep into Go's powerful concurrency features. 📚 Link: [Concurrency in Go](https://lnkd.in/gHWAevG7) 2️⃣ "Event Driven Architecture in Go" - Learn about event-driven patterns using Go. 📚 Link: [Event Driven Architecture in Go](https://lnkd.in/gGG6nSrj) 3️⃣ "Go Web Programming" - Explore building web applications with Go. 📚 Link: [Go Web Programming](https://lnkd.in/gjTaqkck) 4️⃣ "Microservices with Go" - Master building scalable microservices in Go. 📚 Link: [Microservices with Go](https://lnkd.in/gHFN796q) 5️⃣ "Hands-On System Programming With Go" - Delve into system-level programming using Go. 📚 Link: [Hands-On System Programming With Go](https://lnkd.in/gZue-dUR) 6️⃣ "Building RESTful Web Services with Go" - Learn to develop RESTful services efficiently. 📚 Link: [Building RESTful Web Services with Go](https://lnkd.in/gPKcmdDt) 7️⃣ "Cloud Native Go" - Discover how to build cloud-native applications with Go. 📚 Link: [Cloud Native Go](https://lnkd.in/gNWkN6Sf) 8️⃣ "Go Design Patterns" - Explore best practices and design patterns in Go. 📚 Link: [Go Design Patterns](https://lnkd.in/guVStwGW) 9️⃣ "Security with Golang" - Understand security concepts and practices in Go. 📚 Link: [Security with Golang](https://lnkd.in/gQVAs5AF) The key is to keep learning and applying your knowledge. Best of luck on your Golang journey!! Join my LinkedIn newsletter, '[Coding the Future in Go](https://lnkd.in/geFQGKUy)' , and discover Golang in bite-sized insights! #Golang #GoLangDeveloper #BackendDevelopment #Programming #SoftwareDevelopment #Coding #WebDevelopment #Microservices #SystemProgramming #CloudNative #DesignPatterns #Security #LearningResources #DeveloperCommunity #TechEducation #SoftwareEngineering #packtpub #oreilly #manning

37

4 Komentar

𝗛𝗮𝘃𝗲 𝘆𝗼𝘂 𝗳𝗮𝗰𝗲𝗱 𝗮𝗻𝘆 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲𝘀 𝘄𝗶𝘁𝗵 𝗞𝗮𝗳𝗸𝗮??😏. 𝗗𝗼𝗻'𝘁 𝘄𝗼𝗿𝗿𝘆 😎, 𝘁𝗵𝗼𝘂𝗴𝗵; 𝘁𝗮𝗸𝗲 𝗮 𝗹𝗼𝗼𝗸 𝗮𝘁 𝘁𝗵𝗲 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆 𝗳𝗼𝗿 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝘁𝗵𝗲𝗺 𝗯𝗲𝗹𝗼𝘄. 𝗬𝗼𝘂 𝗮𝗹𝘀𝗼 𝗺𝗶𝗴𝗵𝘁 𝗵𝗮𝘃𝗲 𝗳𝗮𝗰𝗲𝗱 𝗯𝗲𝗹𝗼𝘄 𝗺𝗼𝘀𝘁 𝗶𝗻𝘁𝗲𝗿𝗲𝘀𝘁𝗶𝗻𝗴 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲𝘀 𝗮𝘀 𝗺𝗲: 📑 Duplicate message ✘ Error handling while message consumptions 𝗕𝗲𝗹𝗼𝘄 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝘁𝗼 𝗵𝗮𝗻𝗱𝗹𝗲 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲 𝗺𝗲𝘀𝘀𝗮𝗴𝗲: When we publishes an event to a Kafka topic, there is a risk that duplicate events can be written in failure scenarios.  This can be avoided by configuring the Kafka producer to be 𝗶𝗱𝗲𝗺𝗽𝗼𝘁𝗲𝗻𝘁. 𝗗𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲 𝗺𝗲𝘀𝘀𝗮𝗴𝗲𝘀 𝗰𝗮𝗻 𝗼𝗰𝗰𝘂𝗿 𝗶𝗳 𝗶𝘁 𝗵𝗮𝗽𝗽𝗲𝗻𝘀 𝗮𝘀 𝗯𝗲𝗹𝗼𝘄: 1️⃣ Producer writes a message to a topic. 2️⃣ Broker does not acknowledge the write due to some transient failure scenario. 3️⃣ Producer retry as it does not know whether the write succeeded or not. 4️⃣ If the producer is not idempotent and the original write did succeed then the message would be duplicated. By configuring the producer to be idempotent, each producer is assigned a unique Id (PID) and each message is given a monotonically increasing sequence number. The broker tracks the PID + sequence number combination for each partition, rejecting any duplicate write requests it receives. 𝗔𝗻𝗼𝘁𝗵𝗲𝗿 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝘁𝗼 𝗵𝗮𝗻𝗱𝗹𝗲 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲 𝗺𝗲𝘀𝘀𝗮𝗴𝗲 🙋‍♂️  𝗧𝗿𝗮𝗻𝘀𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗮𝗻𝗱 𝗮𝘁𝗼𝗺𝗶𝗰 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴: We can also ensure that these operations are transactional. If any of the transaction fails, it will roll back the event. So far, we have discussed about the duplicate message scenario. But how about 𝗲𝗿𝗿𝗼𝗿 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝘀𝗰𝗲𝗻𝗮𝗿𝗶𝗼??? Wait, lets keep it light & simple, and lets discuss this in upcoming post (soon). Stay tuned and thanks for reading until then. 😊 🔔 Follow Rajiv Ranjan to get more system design & architecture content. ♻ Repost to help others find it. #softwarearchitecture #systemdesign #softwareengineering #reactjs #javascript

20

1 Komentar

Microservice mini-TED talk: A microservice should follow a "sovereign" approach: 1. Independent deployability 2. Independent local data store (not a shared DB) 3. Only need to negotiate public interfaces/events with "customers" 4. Internals are a black box to customers If all four are not true, I don't believe you have a microservice; you have a façade on existing services (aka distributed monolith). Bonus: 5. A microservice UI should try to only speak to its own backend (auth being a major exception) 6. Microservice UI's should not heavily orchestrate among many APIs (creates couplings and interferes with atomicity), try to only communicate with a single API 7. Microservice UI's should also deploy independent of any API 8. Eventual consistency should be favored over brittle HTTP(S) calls for resiliency 9. Events/queues come with tradeoffs, but are worth it Breaking changes are a sin and must be coordinated. It's easier to make additive changes and newer versions when the old one needs deprecated. Change my mind 😏

2

2 Komentar

1/10 Truths in #DistributedSystems Design applied to #ReactiveDDD: "It’s Never Just Two Boxes and a Line!" This truth highlights the risk of oversimplifying the complexity of Distributed Systems. Emergent behaviors are inevitable in such systems, making principles like modeling uncertainties crucial. It's not about achieving absolute control (e.g., deduplication or reordering) but about embracing disorder and designing systems to adapt rather than resist it. In #ReactiveSystems, bounded contexts often interact with multiple others through events. Explicitly modeling this communication is essential, as complexity stems from network latency, failures, and non-linear data flow. Reactive #DomainDrivenDesign (DDD) emphasizes bounded contexts and clear boundaries. What may appear as "just two boxes" actually represents intricate systems engaged in asynchronous collaboration. Subdomain decomposition in #DDDesign further acknowledges this complexity. Each service and its interactions reflect a model specific to the domain, going beyond mere connections to represent purposeful, tailored design. -- inspired by Gregor Hohpe's "10 Truths in Distributed Systems Design" #Microservices #EventDriven #EventDrivenArchitecture #EventSourcing

17

🚀 In this cloud era, switching between #NoSQL solutions could be a great way to save resources and costs, but it could be a nightmare, especially if we're highly coupled to a particular vendor. In this new blog post at Open Liberty blog, see how the flexibility of Jakarta EE NoSQL with an implementation like Eclipse Foundation #JNoSQL could help to solve this issue: 🔗 https://lnkd.in/d7Peek2q

6

Next.js 14/15 + Sanity: Production Development Guidelines Following recent comprehensive audits of several production-ready projects, I've observed patterns significantly impacting performance optimisation and cost efficiency. Critical Observations: - Excessive Sanity API costs from client-side data fetching - Inefficient caching leading to bandwidth overconsumption - Non-strategic API call placement - Legacy SPA patterns in modern architectures - Underutilised image optimisation capabilities - Inefficient video handling leading to storage constraints - Suboptimal GROQ queries fetching unnecessary fields Strategic Recommendations: Server-First Architecture - Default to server components - Maintain server-side queries - Minimise client-side operations - Embrace traditional web architecture principles Media Management - Leverage Sanity powerful Image API for on-the-fly resizing, cropping, and optimisation - Utilise Sanity's built-in image pipeline for responsive images - Video hosting through dedicated services like uploadthing.com, build by Theo Browne - Avoid storing large video files directly in Sanity - Implement proper media caching strategies Query Optimisation - Implement precise GROQ projections to fetch only required fields - Structure queries to minimise API calls - Use efficient filtering patterns - Leverage GROQ joins for related content - Implement pagination where appropriate Caching Implementation - Strategic route segment configuration - Tag-based revalidation - Webhook integration for content revalidation - Native caching optimisation - Proper Sanity Live implementation Performance Optimisation - Combine Next.js Image component with Sanity's Image API - Structured loading states - Robust error handling - Strategic streaming implementation - Optimised API patterns Cost Management - Regular API usage monitoring - Strategic cache deployment - Optimised query projections - Selective static regeneration - Query consolidation - Cost-effective media hosting solutions Key Insight: Modern Next.js with Sanity provides all the necessary tools for exceptional performance. However, our audits show developers approaching these technologies with SPA mindsets, resulting in suboptimal performance and unnecessary costs. Success lies in embracing the server-first architecture that Next.js App Router promotes. Media Management Insight: Sanity's Image API provides robust transformation, negating the need for additional image processing services. Third-party services like uploadthing.com can be used for economical video content storage and delivery. Query Optimisation Insight: Efficient GROQ queries and projections are crucial for optimising API costs and performance. We can significantly reduce bandwidth usage and improve response times by carefully structuring queries to fetch only necessary data. These guidelines come from real-world implementations and audits.

30

Handling message duplication in Kafka #kafka #messagebroker #messageduplication #usecases https://lnkd.in/gGCfCW73

7

JDK 23 Released JDK 23 https://lnkd.in/gjngqMn4 has been released, and its support has already been added to ❤️‍🔥IntelliJ IDEA https://lnkd.in/g4nmUPbU What’s New in JDK 23: https://lnkd.in/g3szrkNQ Generational Z Garbage Collector (Generational ZGC) Enabled by Default. The Generational Z Garbage Collector uses separate handling of "old" and "young" objects, enhancing the efficiency of cleaning up recently created objects with short lifespans. Utilizing Generational ZGC reduces the risk of pauses during resource allocation, decreases CPU load, and lowers memory consumption during garbage collection. Testing Generational ZGC with Apache Cassandra 4 showed a fourfold increase in throughput with a fixed heap size and a quarter reduction in heap size with unchanged throughput. https://lnkd.in/gUUXPkEQ Markdown Support in JavaDoc. JavaDoc now supports using Markdown for documenting code in comments, which can be used instead of a mix of HTML and JavaDoc @ tags. https://lnkd.in/gN9jiVJZ Enhanced Pattern Matching Mechanisms. Pattern matching mechanisms have been extended with preliminary support for using primitive types (int, byte, char, and other basic non-object types) in all kinds of patterns, the instanceof operator, and switch blocks. switch (x.getStatus()) { case 0 -> "okay"; case 1 -> "warning"; case 2 -> "error"; case int i -> "unknown status: " + i; } if (i instanceof byte b) { ... b ... } https://lnkd.in/gHVUaGbK Preliminary Support for import module M. Preliminary support has been added for using a single import module M statement to import all packages exported by the specified module. This change significantly simplifies the reuse of modular libraries, allowing libraries and classes to be connected without specifying their location in the package hierarchy. For example, specifying import module java.base will import all 54 packages included in the java.base module, which previously had to be mentioned individually (e.g., import java.io.*, import java.util.*, etc.). https://lnkd.in/g92V7ty8 Second Preview of the Class-File API. A second preview implementation of the Class-File API has been proposed for parsing, generating, and transforming Java class files. ClassFile cf = ClassFile.of(); ClassModel classModel = cf.parse(bytes); byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { for (ClassElement ce : classModel) { if (!(ce instanceof MethodModel mm && mm.methodName().stringValue().startsWith("debug"))) { classBuilder.with(ce); } } });

4

7 Komentar

As my learning goes on with MongoDB, I found about one interesting thing about how MongoDB handle ID compare to how we deal in the SQL Database. For further reading you can read more here https://lnkd.in/gHZtjish #mongodb #nosql

24

Why is Kafka fast? There are many design decisions that contributed to Kafka’s performance. In this post, we’ll focus on two. We think these two carried the most weight. 1️. The first one is Kafka’s reliance on Sequential I/O.   2️. The second design choice that gives Kafka its performance advantage is its focus on efficiency: zero copy principle.   The diagram below illustrates how the data is transmitted between producer and consumer, and what zero-copy means.   🔹Step 1.1 - 1.3: Producer writes data to the disk    🔹Step 2: Consumer reads data without zero-copy 2.1: The data is loaded from disk to OS cache 2.2 The data is copied from OS cache to Kafka application 2.3 Kafka application copies the data into the socket buffer  2.4 The data is copied from socket buffer to network card 2.5 The network card sends data out to the consumer   🔹Step 3: Consumer reads data with zero-copy 3.1: The data is loaded from disk to OS cache 3.2 OS cache directly copies the data to the network card via sendfile() command 3.3 The network card sends data out to the consumer   Zero copy is a shortcut to save multiple data copies between the application context and kernel context. --  Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://bit.ly/3KCnWXq    #systemdesign #coding #interviewtips  .

3.189

32 Komentar

A high-performing API is the backbone of seamless user experiences and efficient app functionality. This article dives into 5 essential techniques to turbocharge your API performance, ensuring faster response times, improved scalability, and robust reliability. A must-read for anyone looking to optimize their application's potential!

5

🛠️ Golang: the final frontier for simplicity and elegance? Golang. If you’re backend developing nowadays, you must have heard of it. You heard the basics: created by Google, used in many big companies, the shiny thing for backend development. But what makes it so… unique? Well, when I first approached it, it reminded me of lot to C. I guess pointers and structs do the job here. Nevertheless, you definitely feel the modern air from the beginning. And there’s no C in modern. For once, goroutines make concurrency the simplest. It just takes a couple of times to think on channels and architect your application’s data flow in a certain way and voila, you’re done. You don’t have to worry about it anymore. Second, coming from Python where typing is more a choice than even a suggestion, going back to strictly typed languages feels like everything it’s just so much safer. I guess that’s the best scenario for beginner programmers? I don’t mind strictness as long as I still have enough control and flexibility to design my code however I want. Runtime errors are never a nice thing to have. Specially not in production. Now finally, we have to talk about the elephant in the room: Error handling. I consider myself a lover of functional programming,being exposed to haskell during university and then following the functional paradigm whenever I can. Still, being forced to treat errors as a member of a response tuple and and having the linter forcing me to handle those errors every single time, even though it’s supposed to make my code safer and less reckless, most of the time it feels like an annoying Sunday school teacher. Also, the fact that the community is still struggling to come to a standard on how to treat these errors, sometimes gives you this feeling that you are missing out on a best practice. This is a personal opinion, but I still prefer exceptions and try/catch mechanisms versus these ultimate strictness of error handling paradigm. Would I recommend using go every single time? I don’t know really. I think python has a lot of flexibility and a great community behind it, so probably your use is already covered with python — unless you require extra performance or your design is super complicated so that you cannot handle this with an event loop or Threads yourself. Do you want performance? Then probably Rust is your best option as much as I understand but Go gives you a decent results. What has your experience been? Do you use Golan a lot? Are you used to it? Are you forced to using it by your company or is it something that you’ve chosen to? I’m eager to read your thoughts! #golang #backenddevelopment #softwareengineering #python

1

In the era of distributed computing and all its power, it is important to prioritize the essentials of performance (i.e., things that we already have and know work). These techniques offer significant improvements in performance and resource efficiency, and they can address many common challenges faced in high-traffic applications. Focusing on these approaches allows for more immediate and tangible gains compared to investing heavily in complex, distributed architectures, massive messaging systems, or advanced distributed computing solutions.

2

Good morning fellow developers 😎 . Quick go through about MVVM through meme. MVVM (Model-View-ViewModel) - Architectural design Pattern to small scale project. - Clearly separates UI and data layer. - It is life-cycle aware. So, protects data from getting rid on screen orientation. - More over it's bit easy to understand , when compare with clean. #developers_look #Developers_Look

28