Working with structs, generics, enums & types
- Date
- 2025-02-08
- Host
- Polkadot Africa
About this event
If you’ve been meaning to get more confident with structs, generics, enums, and types, this meetup is a practical place to do it. Instead of treating these ideas like abstract theory, we’ll use the session to make them feel understandable, useful, and worth applying in real code. This is also a community gathering, not just a one-way talk. You’ll have space to learn, compare notes with other attendees, and meet people who are working through similar questions about how to model data cleanly and write code that scales beyond the simplest examples. About the Event This event is an in-person community meetup focused on some of the most important building blocks in modern programming: how data is structured, how behavior is generalized, and how types help you write safer, clearer code. Whether these topics are brand new to you or you’ve used them before and want a sharper mental model, the goal is the same: to make the concepts more usable. Rather than trying to cover everything at once, the meetup centers on a focused set of ideas that often unlock a big jump in coding confidence. Structs help you model real-world data in a cleaner way. Enums help you represent states and choices more explicitly. Generics help you avoid repetition while keeping code flexible. And thinking carefully about types helps everything else become easier to reason about. Because this is tagged as a community, networking, meetup, and social event, the format is expected to be approachable and conversational. You should come ready to listen, ask questions, and talk with other attendees about how these concepts show up in your own learning or day-to-day work. What to Expect You can expect a session that balances learning with discussion. The core subject matter is technical, but the environment is meant to stay welcoming and practical rather than overly formal. If you’ve ever left a technical event feeling like you heard a lot but couldn’t connect it back to your own code, this meetup is built to avoid that. Likely points of focus include: How structs help organize data instead of relying on loose variables or ad hoc patterns When enums are the better fit for representing fixed sets of possibilities or application states What generics are really for and why they matter once you start seeing repeated patterns in code How strong type thinking improves design, readability, and confidence when changing code later Questions and peer discussion around confusion points, tradeoffs, and practical use cases Because it’s an in-person meetup, there’s also value in what happens between the formal parts. Expect room for side conversations, quick introductions, and the kind of back-and-forth that helps technical ideas click faster than they sometimes do in solo study. Depending on the flow of the group, the session may move between explanation, examples, and open discussion. That makes it a good fit for people who learn best by hearing different ways of framing the same concept, especially when topics like types or generics have felt harder to grasp from documentation alone. Why Attend A lot of programmers run into these ideas early, but only partly absorb them. You might know the syntax for a struct or enum without feeling fully sure when to use one. You might have seen generics in codebases and understood the surface level, but still hesitate to write them yourself. This meetup is useful because it aims to close that gap between recognition and actual working understanding. Attending can help you build a clearer mental model for how these concepts fit together. Instead of learning them as isolated features, you’ll see them as tools for solving common design problems: representing data, modeling state, reducing duplication, and making code easier to maintain. You’ll also get the benefit of community context. Hearing how other people think about these topics often reveals practical insights that tutorials miss. Sometimes the most useful takeaway is not just a definition, but a simpler way to decide, "Should this be an enum or a struct?" or "Is generics actually the right move here?" If you’re trying to become a stronger developer, these are exactly the kinds of fundamentals that pay off repeatedly. Better type habits and cleaner data modeling improve not only correctness, but also collaboration, debugging, and long-term code quality. Practical Details This is an in-person event taking place on Saturday, February 8 at 4:00 PM GMT+3. If you’re planning your weekend, that timing makes this a strong option for people who want a focused technical meetup without needing to fit it into a weekday work schedule. Since the event is in person, it’s worth arriving ready to engage beyond just the session itself. Bring your curiosity, your questions, and any examples from your own learning or projects that relate to structs, enums, generics, or type design. Even if you’re mostly coming to listen, those concrete questions tend to make the discussion more valuable. A few useful expectations to keep in mind: Location type: In person Date: Saturday, February 8 Time: 4:00 PM GMT+3 Format: Community meetup with learning, discussion, and networking elements Best preparation: Come ready to ask questions and connect with other attendees If these topics have been sitting in the background of your learning for a while, this is a good moment to bring them into focus. You’ll leave with stronger intuition, better questions, and a clearer sense of how to use these tools intentionally rather than mechanically.
Who should attend
This meetup is for people who want technical fundamentals to feel more practical, not more intimidating. - You’re **learning programming or leveling up your foundations** and want a clearer grasp of structs, enums, generics, and type systems. - You’ve **seen these concepts in tutorials, coursework, or codebases**, but you still want help understanding when and why to use them. - You like the idea of a **community-based learning environment** where you can ask questions, compare approaches, and learn from how others think. - You’re building projects and want to **model data more cleanly**, reduce repetition, and write code that’s easier to maintain. - You enjoy meetups that combine **technical discussion with networking and social connection**, rather than a purely formal lecture format. - You’re the kind of person who learns best when concepts are connected to **real coding decisions**, tradeoffs, and examples instead of staying abstract. If you’re curious, motivated, and ready to talk through the details that make code better structured, you’ll likely feel at home here.