Oleg Ponomarev

A total weird thing. Spent hours debugging a query in #Postgres today. The issue? Searching for a word with a German #umlaut ("ü") couldn't find the articles anymore, at least on my machine, despite them existing. I have never faced such issue any more for a long time (although Umlauts caused much trouble very often in older times). Turns out, two 'ü's can look identical but differ in their underlying #Unicode. Ironically, #MacOS underlines the correct one as 'wrong' and types the incorrect one from a German keyboard. Our database (#Postgres) had the correct 'ü', imported from news agencies, but searching with my #Macbook and a german keyboard typed the wrong one. Now I'm going to implement Unicode #normalization in our database for a better search. Finally I understand why airlines and banks still have so many issues with my last name, even in 2024. #UnicodeProblems #DeveloperLife #utf8

12

10 Kommentare

LLMs are tanking the expected lifetime of your software. Well, at least according to this interesting comparison done by Prime! In this example: - A strong engineer gets the initial project setup - They leave the project for other opportunities - Remaining team members take it over - ... They keep it going for a while However... not all projects start with top-performing engineers! Having an LLM write your project is like having a median engineer get the basis for your project kicked off. Would we expect the lifetime of the project to be as long? What are your thoughts on Prime's take here? 👇Check the comments for the full video!👇 ---- 🎬 Check out Dev Leader on YouTube for multiple full-length videos weekly! 🗣️ Share with your network! #SoftwareEngineer #SoftwareEngineers #SoftwareEngineering

7

4 Kommentare

So I became fascinated by C++ coroutines late last week, and have spent a good portion of the weekend figuring out how they work. The TL;DR of my discoveries so far is that C++20 coroutines: 1) follow the best and the worst of C++ practices, and 2) are a really clever way to decouple stackless functions from their execution model. For (1), well, it's C++. No crisp & clean syntax, lots of weird compilation errors, and even weirder runtime errors. I hated them with passion for the first several hours. But then they grew on me, because the flip side is also true. The flip side is backwards compatibility and "only pay for what you use". And introducing a totally new concept — the stackless execution model, effectively, [proto-] green threads — into a mature and complex language is one hell of a pain! For (2), I do believe it's a genius solution for the language to separate stackless functions from their execution model. And C++20 did exactly that. There is literally no event loop in C++20! The claim (as I understand it) is that a tiny microcontroller may want to use C++20 coroutines, and the authors of the Standard are very explicit about not constraining possible runtimes. All that C++20 coroutines do is introduce stackless functions into the language as first-class citizens. And yes, stackless immediately implies resumable. So it is one step about the most-clever-possible syntactic sugar over `setjmp()`. Full one step. But not a millimeter more than this one step. Whether you "execute" your coroutines in a dedicated single-threaded event loop, or a thread-pool-based event loop, or by individual steps via some timer event or even a network packet — that is entirely your call. The stackless functions are there, `co_await` (as well as `co_yield` and `co_return`) is there, no callback hell is needed, and all the RAII and scoped initialization/ownership model is fully intact. Now, I'm still elbows deep in my experiments, but here's the first big LinkedIn-worthy question. Why don't we write our C++20 [unit] tests as corourines? Say, you want to limit some test to five seconds. And fail it as "timed out" within these five seconds. Before coroutines, doing this without instrumenting the very code of the test involved `fork()`-ing the process, effectively relying on the operating system's primitives to ensure proper resource deallocation. With C++20 coroutines, as long as the slow test is slow on non-blocking I/O (i.e. not in an infinite loop, but on something that `co_await`-s stuff), it is possible to time-box each individual test to some five seconds very much organically. Because a coroutine frame, unlike a stack frame, can be `.destroy()`-ed safely and cleanly. So, are we doing it yet? If no, why not? If yes, what would be some next-gen `gtest` to look into? Also, I'll be writing some code and blog posts on C++20 coroutines soon. If you are reading this text and are an expert, DM me pls — I'd love to pick your brain!

19

4 Kommentare

🚀 Choosing a Programming Language in 2024? Let’s Get Practical. If you’re currently deciding which #programminglanguage to learn, take blanket advice with a grain of salt! The #tech landscape has evolved far beyond a one-size-fits-all approach to languages. Today, many languages will continue to have value- even if they’re not dominating job listings. Take #Estonia, where #Java remains a staple for #publicsector projects. In #Lithuania, C# fills a similar role. But beyond regional trends, the best language choice often depends on the specific #task you’re tackling. Sure, you could build almost anything in any language, but that doesn’t mean it’s always the best choice. Case in point: I recently developed a #codereview bot. Since I primarily work with Java, I considered it initially. However, I quickly realized that a #Bash script might’ve been more efficient for #commandline operations but would limit extendability and maintenance. Ultimately, I landed on #Python. It had the client libraries I needed- like #OpenAI and #GitHub- for the first phase. Plus, Python’s #OOP principles made it easier to extend the bot’s capabilities, ensuring scalability and maintainability. When starting out in #softwaredevelopment, aim to learn a range of languages and understand their unique strengths. A #microservices approach, in particular, reinforces the benefit of language diversity. 💬 What do you think? Is it worth sticking to a single language, like #C++, or is flexibility more valuable today? Drop your thoughts below!

1

2 Kommentare

7 ways to slash latency in System Design: When I worked on Meta's distributed data store, managing massive data wasn't the most challenging part – fighting latency was. After years of trial and error, I'm sharing 7 proven best practices for building low-latency systems. 1. Choose the correct architecture Swap slower monolithic architectures for modular, scalable systems that cut latency by operating independently. 2. Optimize data management Choose SQL for structured data or NoSQL for flexibility, and use indexing, sharding, and replication to speed up data retrieval. 3. Improve network design Reduce data travel with CDNs, load balancers, and edge caching. 4. Use efficient communication protocols Use fast protocols like HTTP/2, WebSockets, and gRPC to streamline communication and cut round-trip times. 5. Optimize your code Use efficient algorithms, data structures, parallel processing, and I/O reduction to speed up execution and reduce bottlenecks. 6. Use high-performance hardware Opt for SSDs over HDDs and low-latency cloud services like AWS Global Accelerator for faster performance. 7. Implement smart caching strategies Cache at multiple layers with LRU/LFU eviction and sync updates to avoid stale data. Read the full blog for a closer look at these 7 practices and how to implement them. (Your system—and users—will thank you). https://educat.tv/3B5Dh0N #SystemDesign #SoftwareEngineer

20

Here are the slides for my GopherCon.EU talk: How to Win Frames and Influence Pointers https://lnkd.in/d7byRQfu #gopherconEU #golang

72

4 Kommentare

Interesting happenings … schema governance can be challenging, whether it’s breadth first or depth first, particularly if it’s your first time building graph, or as you adopt federation.

1

This is very exciting news! Unless there are valid security concerns, I think all codebases should be #opensource if their development was financed by public funds. It will be interesting to see if #LLM coding co-pilots will be able to generate more advanced projects after training on such examples.

2

How I Squeeze 60K RPS out of SQLite on a $5 VPS: There are tons of tutorials on how to set up SQLite, and sometimes they contradict each other. Here's what worked for me: 1. Configuring PRAGMAs: We need to send the following PRAGMA commands right after opening the connection: PRAGMA journal_mode = WAL; - Enables write-ahead log so that your reads do not block writes and vice-versa. PRAGMA busy_timeout = 5000; - SQLite will wait 5 seconds to obtain a lock before returning SQLITE_BUSY errors, which will significantly reduce them. PRAGMA synchronous = NORMAL; - SQLite will sync less frequently and be more performant, still safe to use because of the enabled WAL mode. PRAGMA cache_size = -20000; - Negative number means kilobytes, in this case 20MB of memory for cache. PRAGMA foreign_keys = true; - Because of historical reasons, foreign keys are disabled by default; we should manually enable them. PRAGMA temp_store = memory; - Moves temporary tables from disk into RAM, speeding up performance a lot. Do NOT use cache=shared! Some tutorials recommend configuring it, but this is how you get nasty SQLITE_BUSY errors. It is disabled by default, so you don't have to do anything extra. 2. Use immediate transactions: If you know that a transaction can possibly do a write, always use BEGIN IMMEDIATE or you can get a SQLITE_BUSY error. Check your framework; you should be able to set this at the connection level. 3. Open two connection pools: Another trick is to open two connection pools: one for reads only and another for reads/writes. Set the connection limit of the write pool to 1, and the connection limit of the read pool to some reasonably high number, e.g., the number of your CPU cores. Hope this helps!

13

1 Kommentar

Pydantic is amazing because of its Schema enforcement with speed & simplicity. With custom validators, we can make things much better. As a software engineer we live by the DRY(Don't Repeat Yourself) principle. The custom validator which we can write can be reused. In this article, Yaakov Bressler covered different ways of reusing them with code & examples. https://lnkd.in/dNWfAJiA #python #Programming #PythonProgramming #DataScience #MachineLearning #SoftwareDevelopment #WebDevelopment #TechNews #OpenSource #DataEngineering

3

2 Kommentare

Alex Komoroske's writing is so fun to read and so easy to draw lines into our reality: "Sarumans can’t see the value of systems; it will seem too fuzzy and abstract; [...] For similar reasons, a Saruman is deeply skeptical of other people’s perspectives on what’s a constraint, because the only constraints that are real are physical constraints, and everything else is just a fiction in people’s minds that can be overcome with boldness. Sarumans are the kinds of people who build impressive, powerful cathedrals. When you’re building a cathedral, you can’t have naysayers pointing out imagined constraints. You need decisiveness. As they get more powerful, accumulating followers, capital, and respect, it becomes easier and easier to cast the naysayers away. [...] Radagasts intuitively understand the power of the swarm: the system, in its buzzing, blooming, emergent glory. Radagasts know how to let go and dance madly with the system. They don’t try to control the system and its components. They love the system and its components: a love borne out of respect." https://lnkd.in/e9TNgNXb

2

Did you know most open-source LLM models need less than 512 H100 GPUs if the training can span a couple of weeks? With the next-gen Blackwell GPUs, with 2x FLOPs, we need even fewer GPUs for similar training times.   Hyperscalers often build gigantic clusters to run hundreds of training jobs simultaneously and for quick turnaround times for applications needing continuous user data training. However, smaller clusters are more than adequate for most enterprises that either train or fine-tune open-source LLM models.   The network fabric for these clusters could consist of shallow-buffer high-radix switches connected in a fat-tree topology or a modular system that can offer 4x-8x throughput over the shallow buffer switches. For example, the PTX10K8 chassis with #Express5 offers 230Tbps throughput with any-to-any connectivity of 576 x 400G ports where PFEs in the line cards and the fabric switches are connected in a non-blocking CLOS topology - enabling 576 GPUs to be connected with a single system.   PTX10K provides VOQ scheduling to the output ports to eliminate in-cast congestion. Further, packets leaving the PFE towards the switch fabric are broken down into cells, and the cells per destination PFE are evenly sprayed across all available links, achieving over 95% link utilization. Our fabric switch utilizes a buffered crossbar architecture with no head-of-line blocking, sustaining these high link utilizations without backpressure. While cell spraying maximizes link efficiency, it does introduce the challenge of re-ordering and assembling packets from these cells.   How do we tackle reordering? 🤔   Reordering fabric cells is a challenge at which we have always excelled. In fact, our CEO, Rami, who designed the reordering logic for one of our early systems two decades ago, considers it one of his career highlights! At traffic rates of 14.4Tbps per PFE in current systems, with around nine cells to reorder every cycle, the architecture of the cell reorder module is critical to optimize area/power.   As usual, our engineers thrive on such challenges. While I can't disclose all the details of our patented methods, we honed an ingenious approach that writes unordered data into a central buffer while reordering the metadata using a tree-based scheme. This allows for flexible resource sharing across hundreds of reordering contexts, with multiple pipelines working in parallel… The outcome is a compact, highly efficient engine. Combined with our non-blocking fabric switch, this technology enables a true 230Tbps system, connecting GPUs most efficiently in small clusters.    How about large clusters? 🤔 A hybrid approach with modular systems at the spine/super-spine and shallow buffer leaf switches (Juniper's QFX) balances the scale-out and scale-up approaches for better performance, power, and congestion control.   "If your team builds something remarkable, don't hide its light under a bushel" -chatGPT 🙂 #LLMs #genAI #GPUs

227

21 Kommentare

sharpening writing skill is one of killer skill!

2

Arg! After thousands of lines of code cannibalizing the LLVM support library I’ve run into a fundamental design flaw in my approach. Too technical to talk about. Let’s just say I’ve created a set of cyclic dependencies where a depends on b which depends on c which depends on a. It’s because I made a fundamental change to how the library works (which makes it much easier to use when it has to work on different platforms like MacOS and iPads, and is the main reason I went down this path rather than trying to use the library as is) while trying to stick very close to the original structure and design. Not gonna fly. So either I throw out all that work and give up the ease of use - not happening - or I step back and rethink the big picture design elements. And despite the frustration I am loving digging into this library. Usually. By the way this is pretty much what programming is all about - running into obstacles and figuring out how to overcome them. We call it Software Architecture, but it’s not at all like building cathedrals.

6

5 Kommentare

Large language models are wonderful at ingesting large amounts of content & summarizing. Uploading an academic paper and I can pester it with an infinite list of questions & it will respond with equally infinite patience. In comparing the two most recent Microsoft earnings calls, Claude highlighted: - faster than expected Azure growth (29% vs 27%) - AI contributing 8% of Azure revenue up from 7% - higher CapEx spending & greater capacity constraints for data centers - much better commercial bookings growth : 17% vs 13% Excellent analysis. Benn Stancil described LLMs as great averagers of information. But what if I don’t want the average? If I seek the data point two standard deviations out? If I’m channeling my inner Anthony Bourdain & I’m seeking the fermented shark or cobra heart within my query? At Google, we ranked web pages & ads with many signals. An engineer taught me that of them found rarity of a word across a set of documents. For example, if there’s a document containing 10 instances of the word ghotiacross a collection of documents, where the average document has 0 ghotis, that document is likely the best to answer a search about fish. I haven’t found a way to goad an LLM to produce the rare result. Why did one user decide to use a particular piece of software when 10 others did not? Maybe I haven’t learned how to prompt an LLM well. Ideogram launched a feature called Magic Prompt that expands a basic prompt into richer instructions that elicit better results, marrying the language of a user & a computer. A user might write : A boy with a dog in a park. Magic Prompt replies : A heartwarming scene of a young boy playing with his happy, wagging dog in a lush, green park. The boy has a playful smile on his face while he tosses a bright yellow ball for his furry friend to fetch. The park is filled with beautiful flowers and trees, creating a serene atmosphere for this bonding moment between boy and dog. Magic Prompt surprised me in three ways. First, unlike Google search where terse queries tend to work very well, LLMs relish verbosity. Less Hemingway & more Faulkner. Second, maybe there’s a prompt for rarity. If you know what it is, please share with the rarity shibboleth. Third, I wonder what other prompt techniques are out there that have yet to be discovered to wrest the best from an LLM. This technique is called TF-IDF. It means Term Frequency Inverse Document Frequency.

21

6 Kommentare

🚀 Navigating Semantic Versioning Challenges in Rust: A Balancing Act 🚀 Let's talk about something all us Rustaceans have bumped into: Semantic Versioning (SemVer). It’s supposed to help us keep track of changes in our software, but sometimes it feels like it creates more problems than it solves. Here’s why: 1. Breaking Changes: Ever updated a crate and suddenly your code doesn’t work? That’s a breaking change. It’s like someone changed the lock on your door without telling you. Your old key (code) doesn’t fit anymore! 2. Soundness Fixes: Rust is all about safety, but fixing bugs sometimes means breaking stuff. Imagine fixing a crack in a bridge. Sure, it’s safer now, but cars (your code) can’t drive over it until it’s done. 3. Type Inference Issues: Rust’s type system is smart, but adding new traits can confuse it. It’s like getting new shoes that look almost identical. Now, it’s hard to tell which one goes on which foot (or which type the compiler should pick). To make things easier, there’s a cool tool called `rust-semverver`. It helps catch these breaking changes early. You can even integrate it into your CI/CD pipeline to keep things smooth. check the integration code in the comment section #RustLang #SemanticVersioning #SoftwareDevelopment #SupplyChain #InnovationAndStability #DevTools

1

1 Kommentar

Composition of models will bring the next wave of innovation.

2

2 Kommentare

Big moves in DevTools this week! I highly recommend scoping out the launches - links to all can be found in the newsletter (Link in comments). 🏆Funding Wins Neon Lands $25M Investment from Microsoft’s M12 to Expand Serverless Postgres Anysphere Soars with $60M Series A to Build the AI Programmer of the Future Encord Secures $30M Series B to Advance Multimodal AI Data Development 🚀 Lots of Launches minusx.ai Rolls Out AI Data Scientist Extension for Jupyter and Metabase Streos Launches on Product Hunt: AI-Powered Web Design at Your Fingertips Supabase Unveils postgres.new: The ChatGPT of Databases Thunder Compute Launches Cloud Platform to Simplify GPU Scaling Inkeep Wraps Up a Stellar Launch Week, Empowering Docs with AI Search and Support Codeium Crafts Cortex, the AI Engine Driving Developer Innovation Asterisk (YC S24) Debuts AI-Powered Security Platform for Accurate Vulnerability Management 🔦 DevTools of the Week incident.io Expands to Microsoft Teams, Elevating Incident Management Across Platforms AudioEye Empowers Developers with New Accessibility Testing SDK #DevTools #DeveloperTools #Develocity

5

3 Kommentare

Sure LLMs are great but one of the most exciting project of the decade is Ladybird 🐞🐦 The browser market is collapsing: Firefox is dying and Webkit-ish-based browsers represent almost 100% of the users. In this context, out of creating his own retro operating system — which is also bonkers, by the way — Andreas Kling ended up coding a new browser _from scratch_. Obviously, he had an unfair advantage given that he himself participated to the development of WebKit, however nobody did that successfully since the 90s 🤯 While there are no official builds of this project (yet), as the code is entirely open (with a BSD 2-clause license) you can already build it yourself, if you are a bit tech-savvy. On the video below, you can see that I'm playing 2048 inside the Ladybird browser. While the JS performance is far from what Google can produce with millions of dollars, the fact that it works properly is absolutely mind-blowing, especially for an amateur product. Of course today many contributors are helping out the project, and it gained such a momentum that they announced The Ladybird Browser Initiative, a non-lucrative organization destined to the development of this new browser. Chris Wanstrath — found of GitHub — is part of that effort and pledged $1M to support the browser's development. Everyone is free to donate as well. Their idea is to create a browser that will come and challenge the status quo, pushing once again competition in this field that has become entirely dependant on Google's ad revenue. I encourage everyone to learn more about it, and maybe even donate! https://lnkd.in/dNeejTc9

7