Learning Multiple Programming Languages in B.Tech: A Mindset Shift

Everyone asks: 👉 “Which is the best programming language?” But very few ask: 👉 “What logic does this language teach me?” The truth is — there is no “best” language. There is only the language that shapes your thinking. 🟢 C teaches you how memory actually works. 🟢 Java teaches you structured, object-oriented thinking. 🟢 Python teaches you clarity and simplicity. 🟢 JavaScript teaches you asynchronous thinking and real-world adaptability. But here’s the real secret 👇 Languages change. Logic stays. Frameworks evolve. Syntax updates. Trends come and go. But if you understand: ✔ How data flows ✔ How memory is managed ✔ How problems are broken into steps ✔ How systems communicate You can learn any language. The best journey in a developer’s career is not mastering one language. It’s mastering the way of thinking behind them. Because coding is not about typing faster. It’s about thinking deeper. Choose a language. Respect its logic. Learn the fundamentals. And you’ll never fear technology changes again. 🚀 #Programming #DeveloperJourney #CodingLife #TechGrowth #SoftwareDevelopment

📘 Why Can’t Identifiers Start With Numbers in Programming? While learning programming fundamentals, one rule appears in almost every language — whether it’s Java, C, C++, Python, or JavaScript: 👉 **Identifiers cannot start with a number.** But have you ever wondered *why* this rule exists? 🔹 What is an Identifier? An identifier is the name given to variables, methods, classes, or functions in a program. Example: int age = 20; Here, age is an identifier. 🔹 Why numbers cannot come first Programming languages follow strict lexical rules while reading code. The compiler or interpreter must distinguish between numbers (numeric literals) and identifiers (names). If identifiers were allowed to start with numbers, the compiler could become confused. For example: int 1value = 10; When the compiler reads `1value`, it first interprets **1** as a number. It cannot then treat the rest as part of a variable name. This creates ambiguity during lexical analysis, which is the stage where the compiler breaks code into tokens. 🔹 What is allowed instead? Identifiers can start with: • Letters (a–z, A–Z) • Underscore `_` • Dollar sign `$` (in some languages like Java) Numbers are allowed after the first character. Example: value1 user2 count2025 🔹 Key takeaway This rule exists to make programming languages clear, unambiguous, and easier for compilers to parse. Sometimes the simplest rules in programming reflect deeper design decisions in how languages understand our code. #Programming #Java #Coding #ComputerScience #SoftwareDevelopment #LearnInPublic

🚀 Day 18 / 100 Days of Java 💻 Today was all about going deeper into one of the most fundamental topics in programming — Arrays. Even though arrays seem simple at first, they are the backbone of many advanced data structures and algorithms. Here’s what I worked on today 👇 🔹 Understanding Arrays Learned how arrays are represented in memory and why they allow fast access using indexing. This helped me clearly understand how data is stored and retrieved efficiently. 🔹 Finding Maximum & Minimum Elements Practiced iterating through an array to identify the largest and smallest values — a simple yet powerful concept used in many real-world problems. 🔹 Finding the Third Largest Element This pushed me to think beyond basics and handle edge cases like duplicates and ordering without relying completely on sorting. 🔹 Searching an Element in Array Explored linear search and understood where it works best. Also got a glimpse of how search efficiency matters when data grows. 🔹 Finding Missing Number Solved problems using both brute force and optimized approaches. This improved my understanding of patterns and mathematical logic. 🔹 Finding Repeating Elements Learned different techniques to detect duplicates — from basic loops to more optimized methods using extra space. 💡 Key Learnings from Today: ✔ Arrays are not just beginner topics — they are the foundation of problem solving ✔ Writing clean logic is more important than jumping to complex solutions ✔ Edge cases (duplicates, boundaries, etc.) matter a lot ✔ There’s always a better (optimized) way to solve a problem 🔥 Reflection: Every day I realize that consistency beats intensity. Even small concepts, when practiced deeply, build strong problem-solving skills over time. 📈 Slowly but surely becoming better than yesterday. Let’s keep building, learning, and growing 💪 #Java #DSA #100DaysOfCode #CodingJourney #LearningInPublic #DeveloperLife #Programmer #CodingLife #SoftwareEngineering #ComputerScience #TechJourney #ProblemSolving #Algorithms #DataStructures #JavaDeveloper #CodeDaily #Consistency #GrowthMindset #SelfImprovement #StudentLife #EngineeringStudent #FutureEngineer #CodeNewbie #KeepLearning #BuildInPublic #Motivation #Discipline #DailyProgress #NeverGiveUp

I taught several of my coworkers a crash-course on python/powershell and procedural/OO[1] code the other day, and it went well. The crash-course was the most basics of basics: In a turing-complete language[2], you're almost certainly working with state. That state can be constant or variable. It's all binary under the hood, but the binary is understood contextually by its type: int, str, float, bool, etc. Programs are generally accomplished with sequence, selection, and looping. Structured programming having syntax which supports those semantics explicitly, i.e, functions and for/while loops. High-level language dealing not with the machine and often not even directly with memory. We deal with indices based on the number of values. 0 is a value, and the 0th index of a collection maps to a value. I spent a good deal of time explaining that length and index are not synonymous and why. The face-rake of off-by-one errors is always tines-up, and it's very easy to step on it if you don't know it exists. In about an hour and a half-ish, I managed to scratch the surface. Enough to tell someone what they're looking at and encourage them to use learning resources. [1]: I actually really dislike the way most people teach OO code, and I think its owing to C++ and Java. Deeply nested inheritance everywhere, and owing to java in particular, the inability for functions to exist without a chaperone. Like, yes, inheritance is a feature, but really an object is just a data structure bundled and treated as one unit with the means of interacting with that data. Simple as [2]: HTML is a declarative language, which I argue is still a programming language in that it is for telling a computer with rigorous rules what to do.

🚀 Understanding Object-Oriented Programming in Python 🐍 Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of "objects" which are instances of classes. Classes are templates/blueprints for creating objects, and each object can have its own unique attributes and methods. OOP allows for better organization of code, reusability, and modular design. For developers, mastering OOP is crucial as it promotes code reusability, enhances code readability, and makes large projects more manageable. By understanding OOP, developers can create efficient and scalable applications. 🔹 Step by Step Breakdown: 1️⃣ Define a class using the `class` keyword 2️⃣ Initialize the class using the `__init__` method 3️⃣ Create class methods to perform actions within the class 4️⃣ Instantiate objects of the class and access their attributes and methods ```python class Car: def __init__(self, make, model): self.make = make self.model = model def display_info(self): return f"{self.make} {self.model}" my_car = Car("Toyota", "Corolla") print(my_car.display_info()) ``` 🚀 Pro Tip: Encapsulate data within classes by using private attributes (prefix with double underscore `__`) to prevent direct access from outside the class. ⚠️ Common Mistake: Forgetting the `self` parameter in class methods, which can lead to errors in attribute access and method invocations. 🧐 What's your favorite Python OOP concept and why? Share below! 💬 🌐 View my full portfolio and more dev resources at tharindunipun.lk 🌟 #PythonProgramming #OOP #CodeOrganization #LearnToCode #DeveloperTips #PythonClasses #ProgrammingParadigm #CodingCommunity #TechTalk #tharindunipun.lk

🚀 Programming isn’t just about syntax — it’s about mindset. I completely agree with this perspective. In my learning journey, I’ve realized that just knowing languages like Java, Python, or JavaScript is not enough. The real growth starts when you focus on how to think and solve problems. 💡 My thoughts: - Anyone can learn syntax, but not everyone trains their logic. - Debugging has taught me more than copying code ever did. - Building small real-world projects helped me understand concepts deeply. - Consistency matters more than waiting for perfection. 🔥 I believe the goal shouldn’t be to become a “specific language developer”, but to become someone who can adapt, learn, and solve any problem. Still learning, still improving every day 💻 👇 Biggest challenge I’m working on: Staying consistent and improving problem-solving skills. #Programming #CodingJourney #DeveloperMindset #ProblemSolving #LearnToCode #Java #Python #JavaScript #WebDevelopment #MERNStack #Debugging #CodingLife #TechSkills #StudentDeveloper #Consistency #SoftwareDevelopment

I LIKE functional programming. If you know me, you know my passion is Clojure. I like FP thinking, and like to use it. But funnily enough I'm getting the AI to write me an (originally small, but growing) Python application, and one thing that surprises me is that there are lots of things that look like obvious candidates for classes and OO solutions that it, instead, solves with a stack of functions. And even some huge closures. I mean, really big 1000 line closures with dozens of function definitions nested inside. These are obviously classes in all but name. If you're writing python there are times you don't want classes. We've all read "Execution in the Kingdom of Nouns", and laughed at Java (back when all Java functions needed a class escort) But there are definitely some times that classes ARE the right solution in Python. So it's weird. Did OO fall out of fashion and people now think you always need to avoid classes and objects? And the AI training data is now skewed away from them?

I started my DSA journey with Python. It felt natural.   Clean syntax. Less code. Faster thinking. I spent a long time building my problem-solving skills in Python. Then reality hit. Many Online Assessments and interviews were biased towards Java / C++.   And suddenly, Python didn’t feel like enough. So I made a shift. 👉 I moved to Java. Not because I wanted to…   but because I had to. 🔥 That phase was uncomfortable - More boilerplate   - More strict syntax   - Slower implementation  At first, it felt like I was going backwards. But over time, something changed. 🧠 What Java taught me - Writing structured code   - Thinking more carefully before coding   - Handling edge cases with discipline  It made my fundamentals stronger. ⚡ And then came the twist Once I got comfortable in both… I shifted back to Python. 💡 Why? Because now: - My thinking is structured (thanks to Java)   - My execution is fast (thanks to Python)  👉 Best of both worlds 🚀 My current mindset - Language is just a tool   - Strong thinking > fancy syntax   - Adaptability > comfort zone  🧠 Biggest lesson Sometimes you don’t switch because you want to… You switch because the environment forces you. And that pressure?   It upgrades you. ⚡ And now? Honestly… nothing matters anymore. Java, Python… anything works. If you understand the problem,   you can solve it in any language. If you’re confused between languages… 👉 Don’t get attached to one   👉 Focus on thinking   👉 Adapt when needed  That’s what actually wins interviews. #DSA #Python #Java #CodingJourney #InterviewPrep #ProblemSolving

Most beginners think errors are a problem in Python. But in real-world development, errors are expected. APIs fail. Files go missing. Users enter wrong data. The question is not: “Will errors happen?” 👉 It’s: “Can your code handle them properly?” Early in my learning, I used to write code that worked… But the moment something unexpected happened — ❌ Program crashed ❌ No fallback ❌ No control That’s when I understood: 👉 Writing code is easy 👉 Writing robust code is the real skill 💡 Error handling is what makes systems reliable ✔ try → where failure can happen ✔ except → how you handle it ✔ finally → what must always run But the real learning is beyond syntax 👇 📌 In real projects: • You don’t just catch errors → you control failures • You don’t ignore issues → you log and debug them • You don’t rely on success → you prepare for failure 💡 Real examples I covered: ✔ API failure handling (very common in backend) ✔ File handling (missing files, broken paths) ✔ Custom errors using raise (business logic) ✔ Best practices (what most developers ignore) 📌 One important rule: Never write code that only works when everything is perfect. Because in real systems — 👉 Nothing is ever perfect 💬 Let’s discuss (real dev talk): What’s the most common error you’ve handled in your projects? #PythonLearning #PythonDeveloper #CodingJourney #BackendDevelopment #Programming #CleanCode #LearnInPublic #DevelopersIndia #SoftwareEngineering #Python #PythonLearning

🚀 Learning Update: Rules of Method Overriding Today’s class was a powerful deep dive into Object-Oriented Programming (OOP) concepts in Java, focusing on real interview-level understanding rather than just theory. Here’s what I explored: 🔹 Inheritance & Its Terminology Parent Class / Child Class Superclass / Subclass Base Class / Derived Class Understanding how properties & behaviors are inherited 🔹 Access Modifiers in Java public, protected, default (package), private Visibility hierarchy and real-time usage Important rule: Visibility should not decrease in method overriding 🔹 Method Overriding vs Method Overloading Overriding → Runtime polymorphism Overloading → Compile-time polymorphism Learned key rules of overriding: ✔ Same method signature ✔ Same or increased access level ✔ Same return type or covariant return type ✔ Parameters must match exactly 🔹 Covariant Return Types Ability to change return type in child class with inheritance relationship Practical understanding using object return types 🔹 Final Keyword in Java final variable → Constant (value cannot change) final method → Cannot be overridden final class → Cannot be inherited Real-world examples like String and wrapper classes 🔹 Interview Insights 💡 Understanding concepts deeply is more important than memorizing Small mistakes (like confusing overriding vs overloading) can cost interviews Consistent practice and revision is the key to success 📌 Key Takeaway: Concept clarity + Practice + Consistency = Success in Technical Interviews I’m continuing to strengthen my Java fundamentals and preparing for upcoming technical interviews 🚀 #Java #OOP #Programming #LearningJourney #SoftwareDevelopment #InterviewPreparation #CoreJava #StudentLife