Mana Coding: Instant Coding Without Setup

Progress in erlang studies, going through the network programming book have slowed down if we only look at the number of pages, but luckily not in itself. I have spent a couple of days (several hours) going through only 2-3 pages and a handful of extra test cases. This chapter have introduced several concepts and I have made plenty of mistakes that gave me the chance to learn about: - Designing protocols - Human readable vs Binary protocols - unidirectional & bidirectional messages in the protocol (client -> server & broadcast). - Byte representations, base2 , hex, endianness - encoding/decoding from/to binary, iodata() I had deep dives into type definitions, records, header files. Dug into eunit parallel test execution and test generators, created handlers for loggers to capture output in common-test execution in erlang, similarly to how elixir's ExUnit provides a simple macro for this, and implemented a simple_one_for_one supervisor model that made me understand the underlying mechanisms of elixir's DynamicSupervisor. I have also embarked on another side quest for a couple of hours and improved on my dev environment, when I found out that there are cli-based ebook readers, finally I can do everything in one window :). Now I have - terminal multiplexing and session-management using zellij - Helix as my low config TUI editor - gemini cli with a custom sub agent for answering questions - and a spare pane for all project management, file and git operations and running the tests. All of this on a Lenovo chromebook duet, Gianluca Bonetti, if you're still considering getting something similar #erlang #chromeos #cli

Here's a technique I've been using for my Godot development journey, and one I recommend you consider if you try to use the platform yourself: Godot, of course, is a node-based development platform with its own scripting language and the option of using C# .NET. Ultimately, this makes the development practices you have to use to lean heavily towards object-oriented programming. Every node is an object, and every scene is a node. Why is it important to recognise that scenes are just node trees? Because every time you make a scene, you can instantiate that scene as a node in another scene. For example, an interactable container will have a base version stored as a scene. Having this makes it incredibly easy to change how every single version of that object will behave. Previously, I've spoken about trying waterfall-style development cycles for object oriented programming. Already, I've learned how I can improve my planning phase. Before, I would map out the behaviour that I wanted and the basic data trees / structure. Now, I would include maps of how I want the different systems to interact. What data is exposed to where, and how signals are fired between nodes.

In the last post, I said: Dynamic Programming is not about coding… it’s about thinking. Today, let’s break that thinking step-by-step. 👇 Imagine a simple problem: 👉 “You need to climb stairs. You can take 1 or 2 steps. How many ways can you reach the top?” Most beginners do this: Jump straight to code ❌ …and get stuck. But here’s how you should approach it 👇 Step 1: Understand the problem deeply If you are at step 5… how did you get there? 👉 From step 4 (1 step) 👉 From step 3 (2 steps) This is where DP begins. ⚡ Step 2: Define your state dp[i] = number of ways to reach step i Step 3: Write the recurrence dp[i] = dp[i-1] + dp[i-2] Step 4: Don’t forget base cases dp[0] = 1 dp[1] = 1 And that’s it… problem solved. 😌 But here’s the real insight 👇 👉 Every DP problem is about making choices 👉 Each choice creates a subproblem 👉 Combine those subproblems to get the final answer Dynamic Programming = “Breaking a big problem into smaller decisions” Next time you see a DP problem: Don’t think about code first… 👉 Ask yourself: “How did I reach here?” If you understand this, you’ve already solved 50% of DP. Next post: 🔥 Memoization vs Tabulation (the confusion everyone has) Stay consistent… DP will start making sense. 🚀 #DynamicProgramming #DSA #ProblemSolving #CodingJourney #LearnToCode

Day 5 of 30: Classes & Objects in C#. Today I got into OOP (Object Oriented Programming). A class is basically a blueprint. It defines what something looks like and what it can do. An object is when you take that blueprint and actually create something from it. Think of a class as a template for a Car and every car you create from it is an object with its own color, model, and speed. A class holds two things: properties (the data) and methods (the actions). A User class might have a Name and Email as properties, and a Login() method as an action. This is how real applications are structured. Every feature you build in .NET will involve classes. One thing that hit me today: once you understand classes, you stop thinking about code as a list of instructions and start thinking about it as a system of connected pieces. That mindset shift is what separates beginners from developers. Day 6 tomorrow, Inheritance & Polymorphism. How classes can share and extend each other's behavior. #CSharp #dotNET #BuildingInPublic #30DayChallenge #dotNETCore

If you can't pronounce your variable names, you can't discuss your code — rename them to sound like natural language. Let's walk through it in the slides below. #cleancode #code #programming #developer

🧠 Writing code is easy. Designing code that survives change is hard. That’s where SOLID principles helped me. Earlier, my code used to work… But every new feature created new problems: ❌ One change → multiple bugs ❌ Tight coupling → hard to modify ❌ Code became harder to understand over time Then I started applying SOLID (step by step) 👇 🔹 S — Single Responsibility One module, one clear purpose 🔹 O — Open/Closed Extend behavior without modifying existing code 🔹 L — Liskov Substitution Replace components without breaking system 🔹 I — Interface Segregation Avoid forcing unnecessary dependencies 🔹 D — Dependency Inversion Depend on abstractions, not implementations The result wasn’t instant… But over time: ✅ Code became easier to scale ✅ Refactoring became less risky ✅ Collaboration improved ✅ System felt more predictable Biggest learning 👇 Clean code is not about perfection… It’s about making future changes easier. Still learning and applying this in real projects 🚀 Which SOLID principle do you find hardest to implement? #SOLID #CleanCode #SoftwareEngineering #BackendDevelopment #Nodejs #Programming #LearningInPublic

⚡ async vs await in C# They are used together… but they are NOT the same 👇 🔹 async → Used in method declaration → Makes a method asynchronous → Returns Task / Task ✔ Starts the async operation 🔹 await → Used inside async method → Waits for task to complete → Does NOT block the thread ✔ Gets the result of async operation 💡 Simple Way to Remember async → Start the task await → Wait for the result 🔄 How they work together 1️⃣ Method marked with async 2️⃣ await pauses execution 3️⃣ Thread is free to do other work 4️⃣ Task completes 5️⃣ Execution resumes 🚀 Why use async/await? ✔ Better performance ✔ Non-blocking operations ✔ Improved scalability ⚠️ Important Note async without await → runs synchronously await without async → not allowed #dotnet #csharp #asyncawait #backenddeveloper #programming

Programming is not the hardest part Understanding what to build is Most developers spend their time learning new technologies new frameworks new tools But when it comes to building something real they get stuck Not because they can’t code but because they don’t know what actually matters I’ve been there Spending days building features that no one really needed Over time I realized something simple The problem is rarely technical it’s usually about clarity What to build why it matters and who it’s for Code is just the easy part

Rust Programming MasterClass (Updated 2026) by GitforGits | Asian Publishing House is the featured bundle of ebooks 📚 on Leanpub! Build, test, and package Rust the professional way, then accelerate with 100+ practical solutions across performance, CI/CD, and service-style patterns. Add network programming and automation skills, including protocols and packet analysis, so our Rust can power real infrastructure. Link: https://lnkd.in/g3qPNh_4 #rust #data_structures #software_engineering #distributed_systems #apis #computer_hardware #networking #programming_cookbooks #computer_security #operating_system_development

This is pretty exciting: a project built in TypeScript using top-skill was successfully automatically ported to React Native Web, React Native Mobile, and Android Native(!!!). Theoretically, the same approach should enable porting to iOS and any other platforms as well. This is based on Tree-Oriented Programming (TOP) and top-skill created by me — a special AI skill that helps build projects within this paradigm. What does this mean in practice? In a dialogue with AI, a person describes the desired outcome — and the project is then assembled step by step through live interaction. As a result, a prototype very quickly emerges, close to a nearly finished application. Initially, top-skill was designed as a way to maintain control over architecture in the era of mass AI-driven code generation. But in practice, it turned out to provide many additional advantages, including cross-platform project porting and more predictable AI-driven development. top-skill is already published on GitHub: https://lnkd.in/gynjGNbK The book on Tree-Oriented Programming is also ready. I’m currently waiting for the ISBN — and will publish it right after.