in the arrival of the codea series of daily programming challenges released for the first time throughout December. Daily challenges usually contain two puzzles based on similar problems. Although these challenges and problems don't resemble typical data science workflows, I've found that many of the habits, mindsets, and ways of approaching problems they encourage translate surprisingly well to data-centric work. In this article, I reflect on the five lessons I learned from the following actions: the arrival of the code Learn about this year's challenges and how they apply to data science.
For me, the arrival of the code It was a controlled practice environment to refresh the fundamentals and work on programming skills. With no distractions from your daily tasks, you can focus on the essentials. No meetings, changing requirements, stakeholder communication, or coordination overhead required. Instead, there is a simple, binary feedback loop where the answer is either right or wrong. There is no “approximately right”, no way to explain the results, no way to sell the solution. At the same time, you have the freedom and flexibility to choose the approach you think is appropriate, as long as you arrive at the right solution.
Working in such an environment was very difficult, but also very valuable as it revealed habits. Given that there is little room for ambiguity and mistakes cannot be hidden, the flaws in your work quickly became obvious. Over time, I also realized that most of the failures I encountered had less to do with syntax, algorithm choices, or coding implementation, and much more to do with how I approached the problem before touching the code. Below are the key learnings from this experience.
Lesson 1: Sketching your solution – think before you code
One of the patterns that often surfaced during our activities. the arrival of the code My inclination was to jump right into implementation. When faced with a new problem, I was usually tempted to start coding right away and try to arrive at a solution as quickly as possible. Ironically, this approach often produced exactly the opposite result. For example, I wrote deeply nested code to handle edge cases that increased code execution time without realizing that simpler solutions existed.
What ultimately helped me was taking a step back before I started writing code. Instead, we started by focusing on requirements, inputs, and constraints. The process of writing this down gave me a level of clarity and structure that I lacked when working directly on the code. Additionally, I was able to further formalize the required logic by thinking about possible approaches, outlining rough solutions, and working on pseudocode. Once this was done it was much easier to implement via code.
This learning can be applied to data science, as many problems can be difficult because the goals are unclear, the objectives are poorly framed, or constraints and requirements are not well known in advance. You can avoid wasted work by defining your desired outcome and reasoning about solutions before you start writing code. Working backwards from your intended results, rather than moving forward from your preferred technology, will help you stay focused on the actual goals you need to accomplish.
Learning 2: Input Validation – Know Your Data
Even after adopting this approach of sketching solutions and predefining the desired solution, another recurring roadblock surfaced: input data. Some of the failures I experienced had nothing to do with flaws in the code, but were due to assumptions I made about the data that didn't really hold true. In one case, I assumed the data had certain minimum and maximum bounds, but that turned out to be wrong, leading to the wrong solution. After all, code may be correct when viewed in isolation, but fails completely when dealing with data it was not designed to work with.
This once again showed why checking input data is so important. In many cases, it was not necessary to completely refine the solution, and small adjustments, such as introducing additional conditions or bounds checks, were sufficient to obtain an accurate and robust solution. Additionally, early data exploration can provide signals about the scale of the data and indicate which approaches are viable. When faced with large ranges, extreme values, or high cardinality, brute force techniques, nested loops, or combinatorial approaches are very likely to reach their limits quickly.
Naturally, this is equally important in data science projects, where assumptions (implicit or explicit) about the data can lead to serious problems if left unchecked. Investigating data early is a critical step in preventing problems from propagating downstream, where they are much harder to fix later. The key is not to avoid data assumptions altogether, but to make them explicit, document them, and test them early in the process.
Learning 3: Iterate quickly – progress over perfection
puzzle the arrival of the code It is usually divided into two parts. The second often builds on the first, but introduces new constraints, challenges, or twists, such as increasing the size of the problem. Increased complexity often invalidated the initial solution of the first part. Nevertheless, this does not mean that the solution in the first part is not useful, as it provides a valuable baseline.
Having a working baseline like this helps clarify how the problem works, how it can be addressed, and what the solution already accomplishes. From there, you can work on improvements in a more structured way, knowing which assumptions no longer hold true and what needs to change to arrive at a successful solution. Therefore, improving a concrete baseline solution is much easier than designing an abstract “perfect” solution from the beginning.
in the arrival of the codethe second part only appears after the first part is solved, making any attempt to find a solution that works for both parts early on pointless. This structure reflects constraints commonly encountered in practice, as not all requirements are usually known in advance. Trying to predict in advance all the extensions you might need is not only largely speculative, but also inefficient.
A similar principle can be observed in data science. As requirements change, data sources evolve, and stakeholders refine their needs and desires, projects and solutions must evolve as well. Therefore, starting with a simple solution and iterating based on real-world feedback is much more effective than coming up with a completely generic system from the beginning. Such a “perfect” solution is rarely found the first time, and iteration allows the solution to converge to something useful.
Learning 4: Design for scale – know your limits
Iteration emphasizes starting with simple solutions; the arrival of the code We also repeatedly point out the importance of understanding scale and how this impacts the approach used. In many puzzles, the second part not only increases the logical complexity, but also significantly increases the size of the problem. Therefore, a solution with exponential or factorial complexity may be sufficient for the first part, but becomes unrealistic as the problem size increases in the second part.
Even if you start with a simple baseline, it's important to get a rough idea of how your solution will scale. Nested loops, brute force enumeration, or exhaustive search for combinations indicate that the solution stops working efficiently as the problem size increases. Therefore, knowing the (approximate) breakpoints makes it easier to determine if and when a rewrite is required.
This is consistent with the idea of avoiding premature optimization. Rather, it shows that you don't need to immediately implement the most efficient or scalable approach, but rather understand the trade-offs that come with your solution. Designing for scale means being conscious of scalability and complexity, without having to blindly optimize from the beginning.
We will also discuss similarities with data science here. This is because solutions may work well with sample data or limited datasets, but tend to fail when faced with “production-level” sizes. Recognizing these bottlenecks, recognizing possible limitations, and keeping alternative approaches in mind will make these systems more resilient. Knowing where your solution might break can prevent costly redesigns and rewrites later, even if it's not implemented right away.
Learning 5: Be consistent – Momentum trumps motivation
One of the less obvious things I learned from attending Advent of Code was that it had less to do with problem solving and much more to “participate.” Solving puzzles every day sounds manageable in theory, but in practice it was difficult, especially when combined with fatigue, limited time, or lack of motivation, especially after a full day of work. So expecting to be magically motivated again wasn't a viable strategy.
Real progress came from tackling problems every day, not from occasional flashes of inspiration. This repetition strengthened my mindset and allowed me to unpack the problem, which created momentum. Once that momentum was built, progress began to complicate and consistency became more important than intensity.
Data science skill development rarely comes from one-off projects or individual in-depth research. Rather, it comes as a result of repeated practice of carefully reading data, designing solutions, iterating on models, and debugging assumptions made consistently over time. Relying on motivation isn't realistic, but having a set routine can be sustainable. the arrival of the code An illustration of this difference is that while motivation fluctuates, consistency worsens. This daily structure helped me make solving puzzles a habit rather than a desire.
lastly
Looking back, the real value I gained from participating was the arrival of the code It wasn't about solving a single puzzle or learning new coding tricks, it was about visualizing my habits. It highlighted where I tend to rush solutions, where I tend to overcomplicate things, and where I could have saved a lot of time by slowing down and taking a step back. The puzzles themselves were just a means to an end, and the real value was in the lessons learned from them.
the arrival of the code It worked best for me when I looked at it as deliberate practice rather than a competition. Rather than chasing the perfect solution from the beginning, acting consistently, valuing clarity over cleverness, and refining solutions turns out to be much more valuable than finding a single solution.
If you haven't tried it yet, why not try solving the puzzles during next year's event or from the past? This process quickly reveals habits that carry over beyond the puzzle itself. And if you like tackling challenges, you'll find it a really fun and rewarding experience.
