Name: LeetCode 410: Split Array Largest Sum with Binary Search Solution | Satyam Shivhare posted on the topic | LinkedIn
Uploaded: 2025-12-20T17:05:26.313Z
Duration: 14 min 58 s
Channel: Satyam Shivhare

Satyam Shivhare

4mo

I fought LeetCode 410, and the Dynamic Programming almost won. 🏳️ It was 11 PM. My coffee was cold. My confidence was lower than the stock market in 2008. I was staring at LeetCode 410: Split Array Largest Sum. If you haven't seen this problem, it looks innocent. It’s like a wolf in sheep’s clothing, except the wolf is an O(N^2⋅K) time complexity and the sheep is a "Hard" tag. The Problem: You have an array of integers (non-negative). You need to split it into k subarrays. You want to minimize the largest sum among these subarrays. My Brain (Phase 1): The Over-Engineering Phase 🤓 "Ah," I whispered to my empty room. "This is classic Dynamic Programming. I will create a 2D memoization table that tracks the index and the number of cuts remaining. I am a genius." I wrote the code. It was beautiful. It was elegant. I hit submit. LeetCode Judge: Time Limit Exceeded. My beautiful DP solution was too slow. The interviewer (in my imagination) was shaking their head. My imaginary offer letter was shredding itself. The Pivot (Phase 2): The "Wait, What?" Phase 🤨 I stared at the constraints. N is up to 1000. DP is usually fine for that... unless... Then I saw the pattern. The pattern that separates the "Coding Gods" from the "People crying into their keyboards" (me). Binary Search on Answer. "But wait!" you scream. "The array isn't sorted! You can't Binary Search an unsorted array! That’s illegal! That’s against the laws of physics!" Hold on. Put the pitchforks down. We aren't binary searching the Array. We are binary searching the Universe of Answers. 🌌 Think about it: What is the smallest possible maximum sum? It's the largest single element in the array (because you can't cut an element in half). What is the largest possible maximum sum? It's the sum of the entire array (if k=1). The answer is somewhere between max(nums) and sum(nums). Let's say the range is [10, 50]. Is the answer 30? I don't know. Let's ask a Greedy algorithm to check. "Hey Mr. Greedy, can you split this array into K parts where no part is bigger than 30?" If yes -- Great! Try 29. (Minimize it further). If no -- Too tight! Try 31. (We need more room). We just turned a nightmare DP problem into a guessing game. It’s literally the "Higher or Lower" game you played as a kid, but for securing a $200k job offer. The Takeaway: Sometimes, when you're stuck looking for the needle in the haystack (the array), stop looking at the hay. Look at the needle. If the answer space is monotonic... just binary search the answer. It feels like cheating. It feels like magic. But it works. I just recorded a video where I break this down visually so you don't have to suffer through the "DP Phase" like I did. I explain the Check Function logic in a way that even my grandma would understand (maybe). #LeetCode #SoftwareEngineering #CodingInterviews #BinarySearch #DeveloperLife #TechHumor

Transcript

Alex awesome lead court today. So today we have lead court 410 that is split array largest sum. Now this problem is actually a hard problem, but I would call it crazy hard problem because yes there is an intuitive solution to it that you can actually code up and it's sometimes passes on the late code. But the solution that we are going to discuss right now is something that is like the optimal solution and that solution is very tricky to come up with encoding that solution is not hard coding is very easy, but to be able to come up with that kind of solution is very. Non intuitive for beginners at least The best I can say is that if you have solved a lot of problems like this then you will be able to have the intuition to actually go ahead in that direction and discover that solution. So basically in this problem you will be having an integer array nums and you will have an integer K Now we have to split the nums in AK different sub arrays. Remember that we are dealing with sub arrays not subsequences. So the elements needs to be contiguous that is adjacent to each other. Now we need to divide this nums array in K sub arrays in such a way that. The largest sum of any subarray is actually the minimum sum possible. So what does this mean? Suppose that we have this particular array and now we have to divide it with two parts. Now what we can do is we can try to divide it in two parts like this. I can have 8 here 8 will be another sub array and this 72510 will be another subarray 7, two and 5:00 and 10:00. So this is another survey. We have two subarrays and the sum of this subarray is 8. The sum of this subarray is 24 so the largest sum is 24. Now we have to figure out is there a way to divide? This particular array in such a way that this largest sum will actually be less than 24, right? And yes, there is a way so we can divide the array like this from here. Then we will have 7:00 to 5:00 here in one subarray and we will have 10 and eight in another sub array. So the sum here is 18 and the sum here is around 14. So as you can see that the maximum sum actually got reduced to 18 from 24 to 18. And if you try to actually divide it in any other way, then suppose that you want to divide it from here, this sum will actually become greater than a team, right? Yes, this sum will reduce, but it will become greater than 18. So the minimum that you can figure out is 18. So that will be the answer that you need to return. Remember, you are not supposed to return an array because it is very clearly told to us that we have to return the minimized largest sum. So 18 is the minimized largest sum and that's what we are returning here. And here we are only saying that our server is a contiguous part of the array. So it means that I cannot take a 7 and then ten and eight. 7:10 and 8:00 is actually subsequence. It is not a subarray, OK. Now, yes, there is an intuitive way to solve this question. What you can have is you can have a recursive decision tree. So we will have a few choices. Why are we going to have few choices? Well, first of all, we are going to create 2 sub arrays right here. OK, we have to create 2 sub arrays. So I can take this first of all in one sub array and then the rest of the thing will be in another subway, right? Subarray 2. Or I can do something like this. I can take these two in one sub array and the rest of them will be another subarray, right? Or I can do something like this, I can take these three. You know one salary and these two will be another subarray right? Then I can simply take these four in one subarray and this 8 is going to be in another sub array right? And then can I take this whole thing inside of a summary and then let the other array be empty? No, I cannot do that. I need to have something in every array. Why? Because we are supposed to split. We are supposed to split this given array. So that's why this is not valid. We need to have something in every array. So it means till now it is valid. We can have this as one. Everybody this has another summary. So what we have is we have a few decision. So what will happen if I take 7 as first coverage? We have this right? What will happen if I take 7 and two as a first subarray? And then what will happen if I take 7 to 5 as the first subarray? Then what will happen if I take 7 to 5 and 10 as a subarray and here we are taking 7 as the first subarray. All the other elements are going to be part of the other summary, right? And here you can take 7 and two as first array then all of these are going to be. A lot of others are very automatically, yes, we will have to calculate their sum and everything, but that we can do easily in the code. But this is the intuitive way that you can actually solve this question. So you will have 7 here, then you will have a big server a you can divide the subarray in the other branches. You can have more branches everywhere, right? So you can divide it more. And yeah, that's kind of an intuitive way to do this. But this solution does not really pass on the lead code because this solution will actually become a dynamic programming solution. You will have the I and you will have the K. So K is going to be the input parameter that you have. Divided into. So you will have to memorize this thing or you can use two dynamic programming. But at the end of the day, you can have a time complexity like N square K, OK. And we are not going to go through this solution because it is an intuitive solution and it does not really pass on lead code. Yes, there are some optimizations that you can make to make it pass, but we have a better solution. Actually, we have a much better solution, but that better solution is going to crack your head open. Now what we're going to do in this better solution is we are going to use binary search. It is a little bit non intuitive. It is definitely like the best way to solve this question. So how are we going to use binary search on this question? Well, we need to figure out what we were doing in the intuitive solution. What we were doing is that we were taking all the possible sort of sub arrays. So we had possible set of sub arrays, right? We can have 7 as a single sub array and we can have two, 5-10 and eight as a sub array, right? Then we can have something like 7 and two and sub array, right? And then we can have all the other elements like 5-10, eight as another subarray. We are dividing this in two servers because the K is 2. If K was three, we would be trying to divide this in three sub arrays, OK? Then we can have another sub array like this 725 and then we can have 10 and eight in another sub array, right? So this is another set of subarray, right? Then we can have something like a 725 and 10. This is going to make one subarray OK And then we can have other subarray like 8 single right? And now what we are doing is that we had a particular set of subarray right? We had seven and this one. What we will do is we will take the largest sum. So this will be the largest sum somehow, right? So it will come out to be like 25, right? The sum is going to be 25. Then once you have this sum, you can yes, store it somewhere. So you will be having a minimum of 25 as the largest sum that you have figured out till now. Then you will go to the next server reset, OK, Then you will calculate the largest sum here and then it may be something else, right? And then you will go to next subarray. Then you will go to next array and you will keep on calculating the largest sum. And at the end of the day after comparing all of these sets. You will compare all of these sets and you will get an answer like 18 and this 18 is actually coming from this particular set. OK. So what is basically happening is that you are going through sets of subarrays. You have one set, two, set three, set 4, etcetera. OK, We are going through all the four sets of sub arrays and you are figuring out the maximum sum for all of those sets. And then you are actually just getting the answer by comparing all those maximum sums. You're returning the minimum that you can find. And this is the insight where you can actually use binary search and this is where you need to think or understand that. Yes, we have multiple sets of sub arrays, but not all of them are going to be answers, right? But we have to check each and every set. Why? Because we don't have a way to decide whether this particular set is going to be an answer or not. That is the only reason we are going through each and every set. Each and every set needs to be checked just to get the proper answer. So what it means is that if you try to go from sub resets to sum, you will have to check each and every set of sub array, right? But what about the other way around? What if we try to go from sum to subway? Now suppose that. Take a random sum. The sum right now I'm taking is 20. Now I need to figure out is there a way to split this entire array in such a way that the maximum or the largest sum for any sub array is going to be 20 or less than 20. Well we can try to figure that out. So let us put a pointer I on 7. So we will have 7 here. So A7 less than equal to 20. Well yes it is less than equal to 20. So we can make this sub array bigger right? So I take more elements in this sub array. Now I will take two 7 + 2 is what? 7 + 2 is 9 days 9 less than equal to 20. Yes, it is less than equal to 20. So I will go for another one. I will take five. OK, so 7 + 2 + 5 equals to 14. So it's 14,000,000 equal to 20. Yes, I can take another element in this sub array. Now 1410. Now 14 + 10 is 24 and 24 is not less than equal to 20. This is not true right? What it means is that this particular subarray till 10. Is not valid for this sum. The largest sum of this subarray is actually more than 20. But this summary is valid, right? 725 the sum of the seven to five was 14, which was less than equal to 20. So we will have once every like this OK, then we will take 10 in another subarray. So we will have another subway and then we will have 10. So 10. Is 10 less than equal to 20? Yes, it is. So we will again shift the I pointer to the next one and then we will add 8. Then is 18 less than equal to 20? Yes, it is less than. 220 so it means this is also valid. Now if I try to go any further, I don't have any elements, right? I don't have anymore elements. What this means is that I can simply stop the loop and we have two sub arrays like this. We have 725 and we have 10/18. What this means is that we were able to split this array in two parts in such a way that the maximum sum or the largest sum of any of these two arrays is going to be less than or equal to 20. So what can we figure out from this? We know that we need to. Another minimum larger sum. We need to find out the minimum limit of the largest sum, right? So what we know is that since it is actually working for 20, we can try to go for lower numbers. I can go for 19. I can try to split this array into sub arrays in such a way that the maximum sum will be less than or equal to 19. I can try to do that right? Then in the same way I can go to the 18, right? I can try to do that if this also works, if there is actually a way to split this array in such a way that the maximum sum of any sub array is going to be. 18 or less than 18. We can try to go for even lower values like 70 or 16, right? But where do we stop? There is a question, where do we really stop? And the stopping point will have to be the largest element, not the sum, the largest element present in the array. Why? Because if we go any lower than 10, suppose I go to 9, then I will not be able to accommodate this 10 anyways, right? In any of the subarrays. But I need to be able to accommodate 10 also in one of the subarrays. So if I go to 9, if I go to. Eight, if I go to seven, I may be able to accommodate other elements, but I will not be able to accommodate 10 anywhere in any of the subarrays. So that's why 10 is going to be the cap. We cannot go any lower than 10. So we know what is going to be the minimum number that we need to check. But here we started with 20 and 20 was a random value that I took, right? How do I figure out what is going to be the maximum value or the largest value we can take and we can start from there. Well, we know that the K is equal to two, right? Which means we need to divide this into two sub. So what we can do is we can take the array and divide it into two parts. 1st is 7, the other one is stays right? Then I can divide it into this part. Then I can divide it into this way. Then I can divide it into this way. And then I just take the maximum that is present, the maximum largest number I could find out and I can take that as the upper limit. OK, But this way is not really very good at the end of the day, we just want to find out the upper limit. That upper limit does not have to be true, right? It just needs to be the upper limit, the place where we can start from. So the best way to do this is actually. Just take all the elements and sum them up. OK, so if I take all the elements and sum them up, we will get 32. So 32 is the largest sum that we can get from this array. OK, so I can take 32 as the upper limit. So what this means is that the answer is going to be somewhere between 10 to 32, right? So we will have an answer between 10 to 32. And we know that for this particular array, the answer is going to be 18. So yes, 18 exists between 10 and 32. So we also have this way right I can. Because Sam and I can try to figure out if I can split this particular array into two subarrays such that the largest sum of any subarray is going to be less than or equal to 32. If it is less than or equal to 32, I can try to find out the lower numbers. I can try to check for lower numbers. If it is not less than equal to 32, I know that I need to go up. I need to figure out a bigger number. So here you can see that we have a condition and we can go either this side or this side, right? Do you understand? I can check for lower numbers or I can check for upper numbers based on a condition. And that's why we can use binary search. Remember that yes, we can go ahead from 32 till 10 and search for all of the values, just figure these things out for all of the sum. But if we try to do this, we will end up going through each and every set of sub arrays again, right? We don't want to do that. We don't want to go from 32 to 31 to 30 to 29 and all the way to 10, checking everything, right? Because it will not help us in any way. It will just make us go through the entire set of sub arrays again and again and again. So what we need to do? We need to observe that, look, we are not supposed to check for each and every value, OK, we have a particular answer that we need to search, OK, we need to find out the minimum possible answer, right? So basically, we have a set of these numbers and we need to search for a particular number based on a condition. So I can Simply put binary search on it, right? Instead of going through every element or every number or every sum, I can just divide and then check for the condition and then and then simply eliminate half of the search space each time, right? And that will help us a lot and speed. You are searching very quickly. So that is why we are going to use the binary search on the possible sum, right? The possible sum for this particular situation is just 10 to 32. OK, for other array it can be different. All you have to do is just take the largest element from the array and then just take the sum of the entire array. That will give you the range in which you need to perform binary search. Now there is one more thing I want to clarify here. So here we have KQRS to two, right? But what if it was not true? It was actually 3 and then here we were able to just take the 2 arrays. We were able to split in two arrays and the sum of each array was less than equal to 20. So will it be a problem if I just split it in two arrays, OK and not 3 arrays? Well, no, it is not going to be a problem. Why? Because if we have the largest sum in any of these arrays less than 20, then we can simply take that largest array and break it in two parts, right? So I can have 5:00 and 10:00 and I can have seven and two and the sum of these individual arrays is also going to be less than 20, right? So that's. Don't have to exactly make 3 subarrays. If I can make 3 or less than 3 subarrays and make sure that for all of the sub arrays this particular condition is true, the largest sum of any of those servers is less than 20. I know that this particular number is fine. OK, we can look for lower numbers, we can look for 1918 or some other number. But if I end up figuring out that no, I actually had to create more than.

To view or add a comment, sign in

More Relevant Posts

Ed Sweeney
4mo
Report this post
In experimental electronic music making we sometimes say "limitations spark creativity". In making the new programming language "seq" it is like I was drawing cards from Brian Eno's "Oblique Strategies" and the card I drew said "make a programming language with NO VARIABLES". Seq is a strongly typed compiled computer programming language that uses the same LLVM compiler backend as C/C++ and Rust, is point-free (no named variables), stack-based (like Forth), with CSP built-in (like go's goroutines) and ADTs (like Rust's enums, Options, Results, more) and innovative compile-time safety around stack effects. #programming #creativity https://lnkd.in/gquz3ywC

GitHub - navicore/patch-seq: another try at a contactinative language separating stack node from value github.com

2 Comments
Like Comment
To view or add a comment, sign in
Luis Oria Seidel

| IT Manager & Cybersecurity Architect | Automation with N8N and Make | Artificial Intelligence | Fortinet® NSE 3 & FCAC® | ISO/IEC 27001 ™ | CAPC™ | Cloud | CSFPC™ | SODFC™ | FBE™ | RWVCPC™ | NIST | ITIL | FCP | CobiT |
3mo
Report this post
🚀 Discovering the World of Custom Programming Languages In the fascinating universe of software development, creating your own programming language represents an exciting challenge that combines creativity and deep technical expertise. Recently, I explored an article that details the step-by-step process of a developer who built their own language from scratch, inspired by the need to simplify specific tasks and experiment with innovative paradigms. 💻 The Origin and Initial Motivation It all began with the idea of solving everyday problems more efficiently. The author, motivated by curiosity and the desire to understand the fundamentals of compilers, decided to embark on this personal project. Using accessible tools like LLVM for the backend, they avoided reinventing the wheel and focused on the essentials: a simple lexer and a recursive descent parser. 🔧 Key Steps in Development - Lexer and Tokenization: The first stage involved breaking down the source code into tokens, handling basic expressions and operators with precision to avoid common errors. - Parser and Syntax Tree: Building an AST (Abstract Syntax Tree), the grammatical rules were translated into manageable data structures, allowing for quick evaluations. - Code Generation: Integrating with LLVM IR, the language generated optimized machine code, supporting primitive types and recursive functions. - Testing and Debugging: Constant iterations revealed challenges such as scope handling and garbage collection, resolved through exhaustive unit tests. This approach not only resulted in a functional language for simple scripts but also offered valuable lessons about the underlying complexity of languages like Python or C++. It's a reminder that innovation in programming arises from practical experimentation. For more information visit: https://enigmasecurity.cl #SoftwareDevelopment #ProgrammingLanguages #Compilers #TechInnovation #Programming Support Enigma Security by donating here for more technical news: https://lnkd.in/er_qUAQh Connect with me on LinkedIn to discuss more about these topics: https://lnkd.in/eXXHi_Rr 📅 Sat, 17 Jan 2026 08:22:04 GMT 🔗Subscribe to the Membership: https://lnkd.in/eh_rNRyt
Like Comment
To view or add a comment, sign in
Nishantha Ruwan
4mo
Report this post
The paper introduces EnCompass, a new framework for designing and implementing LLM‑based agents that separates the description of an agent’s workflow logic from its inference‑time search strategy. Traditional agent programming often intertwines these concerns, making it hard to experiment with different execution strategies without rewriting core logic. EnCompass instead uses a programming model called probabilistic angelic nondeterminism (PAN) to cleanly decouple the two. PAN lets developers write workflows that implicitly define a space of possible execution paths; the system then performs search over these paths at inference time. This separation enables more flexible experimentation and tuning of search strategies—including tree search and other planners—without modifying the high‑level agent code. The authors implement PAN in Python within the EnCompass framework, employing a decorator‑based API that automatically compiles workflow programs into a structured search space. They demonstrate the approach on three case studies, showing that programmers can rapidly improve agent reliability or switch inference strategies with minimal additional coding. The results suggest that disentangling workflow design from search heuristics not only simplifies agent development but also makes it easier to explore diverse execution‑time techniques, potentially improving robustness and performance in complex tasks. https://lnkd.in/gERcwTMF

EnCompass: Enhancing Agent Programming with Search Over Program Execution Paths arxiv.org
Like Comment
To view or add a comment, sign in
Enigma Security

924 followers
3mo
Report this post
🚀 Discovering the World of Custom Programming Languages In the fascinating universe of software development, creating your own programming language represents an exciting challenge that combines creativity and deep technical expertise. Recently, I explored an article that details the step-by-step process of a developer who built their own language from scratch, inspired by the need to simplify specific tasks and experiment with innovative paradigms. 💻 The Origin and Initial Motivation It all began with the idea of solving everyday problems more efficiently. The author, motivated by curiosity and the desire to understand the fundamentals of compilers, decided to embark on this personal project. Using accessible tools like LLVM for the backend, they avoided reinventing the wheel and focused on the essentials: a simple lexer and a recursive descent parser. 🔧 Key Steps in Development - Lexer and Tokenization: The first stage involved breaking down the source code into tokens, handling basic expressions and operators with precision to avoid common errors. - Parser and Syntax Tree: Building an AST (Abstract Syntax Tree), the grammatical rules were translated into manageable data structures, allowing for quick evaluations. - Code Generation: Integrating with LLVM IR, the language generated optimized machine code, supporting primitive types and recursive functions. - Testing and Debugging: Constant iterations revealed challenges such as scope handling and garbage collection, resolved through exhaustive unit tests. This approach not only resulted in a functional language for simple scripts but also offered valuable lessons about the underlying complexity of languages like Python or C++. It's a reminder that innovation in programming arises from practical experimentation. For more information visit: https://enigmasecurity.cl #SoftwareDevelopment #ProgrammingLanguages #Compilers #TechInnovation #Programming Support Enigma Security by donating here for more technical news: https://lnkd.in/evtXjJTA Connect with me on LinkedIn to discuss more about these topics: https://lnkd.in/ex7ST38j 📅 Sat, 17 Jan 2026 08:22:04 GMT 🔗Subscribe to the Membership: https://lnkd.in/eh_rNRyt
Like Comment
To view or add a comment, sign in
Muhammad Faisal
3mo
Report this post
In all programming languages we use comments to explain the code or to identify the specific block of ode easily. **The compilers do not compile the commented code**. With respect to the language the syntax of the single line and multi line comments is different. Similarly in Dart programming language we use comments. The syntax of the comments in dart programming language is very easy. When we write a lot of code then it becomes difficult to find a specific code according to their working. So we use comments to specify the code with respect to their function. Sometimes if we do not need a specific block of code at the moment then we can also comment that code and the compiler will not execute that code. **Syntax of Comments in Dart Programming Language** There are two types of comments in Dart programming language. * Single Line Comments * Multi Line Comments **Single Line Comments:** As from the name we can guess that this is a comment which is used to comment a single line of code or any simple text. If we want to comment a single line of code in the dart programming language then we have to use two forward slashes `"//"` at the start of the line. It will comment out that line and the compiler will not compile that commented line of code. **Multi Line Comments:** If we want to comment more than one line of code then we use multi line comment option. It is also very simple and easy. We use a forward slash and star "`/*"` at the start of the first line from where we want to start commenting and similarly we use a star and forward slash `"*/"`at the end of the line where we want to end the comment. All the lines between these points will be commented and the compiler will not compile them. Fore more detailed information go through this article: https://lnkd.in/ds82g2zM #dart #flutter #programming #comments #comments_in_dart
Like Comment
To view or add a comment, sign in
Edgars Brokans
3mo
Report this post
Programming languages are basic element. Software libraries are language extension since introduces new words. Each project builds small universe, space - where words lives. Each developer builds own libraries - extends language with own constructs. So chosen programming language plays quite small role. Main building is done with project introduced words. From my opinion - better is try avoid using of standard libraries for long term. Instead develop own basic elements and abstractions. And project itself is set of text files containing language elements-expressions. Text files are used because we can read, write, print, compare, edit and interpret by compiler or executor. And software project can become very big, complex and hard to maintain. For this reason new languages are developed with hope to do this better. And I also have fresh idea about new language. We need introduce code layers. Layers like Photoshop, Illustrator or Paint.NET image layers. At one layer we could write basic logic. At next layer error checking. Additional layer for assurance of correct parameters, layer for memory management, object life cycle... And editor could show or hide layers, put breakpoints, separately stored in source control system. Idea is not very new. HTML and CSS, JavaScript files also is attempt divide project in to layers. C++ include files, preprocessor definitions - also are layers. Programming comments also are some sort of layer. But we need developer defined layers according to project structure, not only language implementation. Enable-disable execution of some layers while debugging. Program description, project documentation, user manuals... also are layers. And all layers needs to be synchronized, shown, hidden, checked, corrected somehow by IDE. Language is way how to organize all such layers.
Like Comment
To view or add a comment, sign in
kartik sharma
4mo
Report this post
🚀 Meet the Visionaries Behind Popular Programming Languages Behind every powerful programming language, there is a brilliant mind that shaped the future of technology. These pioneers laid the foundation of modern software development, web technologies, and computer science as we know it today. 👨💻 Creators Who Changed the Tech World: Dennis Ritchie — C Bjarne Stroustrup — C++ Anders Hejlsberg — C# James Gosling — Java Brendan Eich — JavaScript Rasmus Lerdorf — PHP Yukihiro Matsumoto — Ruby Guido van Rossum — Python Larry Wall — Perl ✨ From system-level programming to web and AI, these languages power billions of applications worldwide. Their creators didn’t just write code — they built the backbone of modern technology. #Programming #Coding #Developers #ComputerScience #SoftwareEngineering #TechHistory #ProgrammingLanguages #LearnToCode #Python #Java #JavaScript #Cplusplus #CSharp #PHP #Ruby #OpenSource
2 Comments
Like Comment
To view or add a comment, sign in
Blaise Rettig
4mo
Report this post
For the past six months, I have been developing my own programming language. It is finally at the point where I can share it! Group18 (g18) is a strongly-typed educational programming language and compiler written in Rust that compiles directly to x86-64 assembly as well as WebAssembly. I’ve open-sourced the compiler and built an online playground where you can write code (and view some pre-made programs) and see the generated output. Go check it out here: https://lnkd.in/gMuAazt4 (possible on mobile, but computer recommended). Check out the repo here if you want more technical info or want to install the language on your own machine: https://lnkd.in/gf7kDTQU The project implements the full compilation pipeline end-to-end: lexing, parsing, AST construction, type checking, and native code generation. The language uses a simple C-like syntax with functions, control flow, arrays, and a strong static type system. It gets its name from the 18th group of the periodic table, the noble gases, which are extremely stable and useful! This project represents a massive undertaking and effort, but I am proud of the progress so far. Jonathan Weinberger and Alexander Kurz deserve a great deal of credit for motivating me to further develop this and for providing helpful resources, so thank you! Feedback and contributions welcome!

GitHub - blaiserettig/Group18 github.com

6 Comments
Like Comment
To view or add a comment, sign in
Sergey Bogdanov
3mo
Report this post
This is the number of questions asked on Stack Overflow. Take a look at 2024 and 2025. Yes - it drops to nearly ZERO. This single image shows a tectonic shift in how development works today. There are three possible explanations: > The data is wrong > Developers suddenly stopped asking questions (they didn’t) > LLMs are now handling most of the work for them When I was at school, I learned low-level programming (Turbo Assembler back then). Today, you almost never touch that layer. In the vast majority of real-world tasks, you don’t need to understand how the machine works internally - you operate at a much higher level. Most of my projects are written in TypeScript, JavaScript, Python. You don’t think in instructions anymore - you think in packages, APIs, and abstractions. This graph tells me that eventually you won’t even need to know programming languages at all. You’ll work with high-level concepts, and programming will look like plain English (or any other human language).
98 Comments
Like Comment
To view or add a comment, sign in
David Schryer
3mo
Report this post
Stack overflow is indeed dead but it seems like this article, many others, and all the commenters are missing the main points: 1. New LLM learners (most of us in some domains) don’t know they should focus on understanding over building. What questions should they be asking to prioritise learning? 2. Everyone now relies on LLMs they effectively need to pay for to both learn how to code and code effectively. What does the learning path look like for those without access? I would like to see articles on: 1. How LLM learners phrase their line of questioning so they can learn the trade offs between different solutions and pick the best one. 2. How tool authors can provide MCP servers and a learning experience that helps their users learn best practices — without relying on proprietary software. 3. Learning how to write efficient and maintainable code in an accelerated LLM world where learning seems optional. 4. Leadership principles on how to coach teams on how to build quality resilient and maintainable software while learning and teaching each other why it is quality resilient and maintainable. My thesis in all four would be: When writing code to be used by other people, prioritising learning over doing is almost always the best path forward.
Sergey Bogdanov

Founder, CEO, CTO
3mo

This is the number of questions asked on Stack Overflow. Take a look at 2024 and 2025. Yes - it drops to nearly ZERO. This single image shows a tectonic shift in how development works today. There are three possible explanations: > The data is wrong > Developers suddenly stopped asking questions (they didn’t) > LLMs are now handling most of the work for them When I was at school, I learned low-level programming (Turbo Assembler back then). Today, you almost never touch that layer. In the vast majority of real-world tasks, you don’t need to understand how the machine works internally - you operate at a much higher level. Most of my projects are written in TypeScript, JavaScript, Python. You don’t think in instructions anymore - you think in packages, APIs, and abstractions. This graph tells me that eventually you won’t even need to know programming languages at all. You’ll work with high-level concepts, and programming will look like plain English (or any other human language).
Like Comment
To view or add a comment, sign in

1,469 followers

218 Posts

View Profile Connect

Transcript

More Relevant Posts

Explore content categories