The hardest part of software engineering is getting your first role.

The next hardest part? Realising how little you know.

Then comes trying to write code that lasts.

After that? watching others fly while you feel stuck.

And just when you think you’ve figured it out: someone shows you how much you still don’t know.

The journey never gets easier.
You just grow stronger at facing it.

So if you’re struggling to land a role, chasing a promotion, fighting doubt, or feeling unseen — keep going.

The learning never ends.
The doubts never vanish.
But neither does the growth.

Credit

🎙 Open Mic Session: Featuring Ruth Abiti Getaneh

We’re excited to host Ruth Abiti Getaneh, a Software Engineer with 3+ years of experience building scalable, production-ready systems across healthcare technology and enterprise applications.

Ruth specializes in mobile development with Flutter and Riverpod, and web applications using Angular and ASP.NET. Her work spans RESTful APIs and data-driven dashboards — all grounded in Clean Architecture, Domain-Driven Design (DDD), and CQRS.

✨ In this session, expect:
🔹 Building scalable healthcare and enterprise systems
🔹 Mobile vs web architecture decisions in real projects
🔹 Writing code that your future self will thank you for
🔹 Career growth, teamwork, and open Q&A

📅 Date: Friday, December 19, 2025
⏰ Time: 8:00 PM / 2:00 LT
📍 Live on the GDG AAU Channel

Follow us for updates:
| Telegram  | LinkedIn  | Instagram | TikTok | Face Book | X

#GDGAAU #OpenMicSession

Real experience doesn’t come from watching more tutorials. It comes from building, thinking, and solving real problems. Tutorials are useful at the beginning, but staying there too long gives a false sense of progress. You may understand concepts, but you don’t truly learn until you apply them on your own.

The best way to gain experience is to start with a problem you actually see or face. It can be something small, a task you repeat every day, a manual process, or a tool you wish existed. Start there. Google similar ideas, read how others solved it, and then try to build your own version. It doesn’t need to be perfect. What matters is that the decisions are yours.

When you work on your own project, learning becomes real. You think about structure, logic, edge cases, and how things behave in real situations. You get stuck, search for answers, read documentation, try again, and improve. This is exactly how professional developers work.

Spending too much time watching tutorials without writing code keeps your hands clean, but experience comes when your hands get dirty. Writing imperfect code, fixing it, and improving it over time teaches you far more than any video can.

Experience is built by doing real work, not by waiting to feel ready. Start small, build something real, and learn along the way.

@edemy251

Its fully Confirmed now That Anthropic is adding Ethiopia to Supported Countries List!!!

Its rolling from Claude code first!

Good Morning Pioneers! 👋 I'm Kal, and I'll be taking over from here! Just wanted to let you know we'll be continuing our discussion on Python, focusing on language features and development tooling 🐍🛠. If you're new to Python, you should start with the topics covered in Python Basics 📚✨.

In the tech world, things change fast. Adapting to these changes quickly is what helps us stand out as better programmers. Project changes are tracked using version numbers—and they aren't random. They convey crucial information about the current state of a project.

The Python project uses a major.minor.micro versioning scheme for production releases (the versions we care about most!). Here is how it breaks down:

🔹 Major version (x.0.0): These are rarely incremented. They only occur when there are significant backward-incompatible changes or a complete, ground-up redesign of the project. These updates are planned years in advance. Python has only had four major versions in its history: 0.x.x, 1.x.x, 2.x.x, and 3.x.x (our current version).

🔹 Minor version (0.x.0): These are incremented for new features and library deprecations. They can sometimes introduce breaking changes too. In Python's release cycle, a new minor version comes out every year in October.

🔹 Micro version (0.0.x): These updates are reserved for bug fixes and security patches on an existing minor release.

As of today, the current stable release of Python is Python 3.14.5. 🐍

#GettingToKnowPython #PythonProgramming #CodingTips

List comprehensions
List comprehensions are expressions that allow us to transform lists in a single line. The syntax:

[ <inner_expression> for <item> in <list> ]

It may look intimidating at first glance but what will happen is python loops through the list and executes the <inner_expression> for each <item> in <list> to create a new list.

# Example
nums = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in nums]
print(squared)

# output: [1, 4, 9, 16, 25]

Above we have two expression the outer_expression which is the list comprehension itself and the inner_expression (n ** 2) which transforms the list. In this case the inner_expression squares each item from the list.

#PythonTips #GettingToKnowPython #PythonPatterns

Lambda functions
Another cool expressions or patterns in python are lambda functions a.k.a anonymous functions. We use them to define functions inline (in one line).

# Syntax
lambda arguments: expresion

The subtle thing we need to understand about anonymous funtions/lambda functions is that they don't have a name unless we explicitly assign them to a variable. The return value of lambda function is the evaluated expression.

The concept actually exists in many programming languages as anonymous functions or function expression, even-though the syntax could be different.

# Examples

# This is valid - With no name
lambda x: x     

# With a name
times2 = lambda x: x * 2 

# With two argumetns
prefix = lambda pre, post: pre + post;  
postfix = lambda post, pre: prefix(pre, post) 

print(times2(10))     
print(prefix("main", ".py"))
print(postfix(".py", "main"))

# ----------Output---------- 
20
main.py
main.py

#LambdaFunctions #PythonProgramming #PythonTips #GettingToKnowPython

Explanation

# given data
words = ["to code", "python", "linux"]

# func - prefixes any given string with 'I love '
func = lambda word: "I love " + word

# transforms every item using - func
results = [func(w) for w in words]

# results
# ["I love to code", "I love python", "I love linux"]

# results[1] - is the second item
# Remember indexes start from 0 not 1
print(results[1])

# Correct Answer: "I love python" (option 1)

Happy coding 😊

We now have a new community group to discuss on different topics


You can also dm additional topics to be created

https://t.me/python_pioneers_com

OOP in Python

Object Oriented Programming (OOP) just means we organize code using objects that have Data and Actions. Data is something we know about the object, and Actions are things we can do to the object or with the object.

For example, when looking at a computer, we may find ourselves asking the brand, model and specs of a computer, these are some of the data(information) we can have about a computer. Also we can do things on a computer; power it On & Off, Open & Close apps, adjust the volume - these are some of the action we can take on a computer.

Note: In the context of programming we usually say Attribute or Property instead of Data and Method instead of Action.

...continued

To do OOP in python we use classes. Classes define the shape (attributes and methods) of an object. Think of classes like a blueprint for creating objects. Next we use classes to create objects.

It's a simple two step process:-
• Modeling:- defining a class (shape).
• Instantiating:- creating objects (instances) using class.

Syntax: to create a class we use the class keyword.

# Step 1 - Modeling
class ClassName:
  attr1 = 0 
  attr2 = True
  attr3 = "string"
  
  def method1(self): pass
  def method2(self): pass
  
# Step 2 - Instantiating
obj1 = ClassName() 
obj2 = ClassName()

Note:
• Attributes can be of any data type.
• Methods are just functions attached to the object.
• self is a reference to the object; obj1 or obj2 (we will talk more about them later)

...continued

To access attributes or call methods on an object we use a dot-notation., the variable followed by dot and the attribute or the method name.

Syntax: the dot-notation

# Accessing an attribute
object.attribute

# Calling a method
object.method()

Example: simplified computer object

class Computer:
    # __init__ is a special method (a constructor)
    def __init__(self, brand, model):
        # attributes
        self.brand = brand 
        self.model = model
    
    # methods
    def powerOn(self):
        print(f"Powering on {self.brand} {self.model}")
  
    def powerOff(self):
        print(f"Powering off {self.brand} {self.model}")
      
c1 = Computer("HP", "OMEN")
c2 = Computer("Dell", "XPS")

# Test code
print(c2.brand + " " + c2.model)
c1.powerOn()

# Output
Dell XPS
Powering on HP OMEN

#oop #PythonProgramming #DotNotation

Discover a Smarter Way to Learn & Share Knowledge

As a ScholarXiv Ambassador, I’m excited to introduce you to ScholarXiv — a platform built for students, researchers, academics, and lifelong learners who want to discover and share scholarly knowledge.

Whether you’re working on an assignment, research project, thesis, or simply exploring a new field, ScholarXiv can help you connect with academic resources and ideas.

🔬 Research. Learn. Share. Connect.

If you’re serious about your academic journey, take a look at ScholarXiv and see what it has to offer.

👉 Explore: scholarxiv.com